Added defaults to converter settings so converter can be used without connector

Merge pull request #177 from specklesystems/jrm/chore/comments
chore: fixed some mistakes in code comments
2023-10-18 15:48:31 +01:00 · 2023-10-16 11:43:58 +01:00 · 2023-10-16 11:43:36 +01:00 · 2023-10-13 13:02:28 +01:00 · 2023-10-13 12:56:30 +01:00 · 2023-10-08 18:45:50 +01:00
29 changed files with 3818 additions and 2695 deletions
@@ -1,143 +1,307 @@
 version: 2.1

 orbs:
-  python: circleci/python@1.3.2
-  # Using windows for builds
-  win: circleci/windows@2.4.0
-  # Upload artifacts to s3
-  aws-s3: circleci/aws-s3@2.0.0
+  win: circleci/windows@5.0.0

 jobs:
-  build-connector: # Reusable job for basic connectors
-    executor:
-      name: win/default # comes with python 3.7.3
-      shell: cmd.exe
-    parameters:
-      slug:
-        type: string
-        default: ""
+  package-connector:
+    docker:
+      - image: cimg/python:3.11.0
    steps:
      - checkout
+      - run:
+          name: Setup SEMVER value
+          command: |
+            SEMVER=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "0.0.0"; fi;)
+            echo $SEMVER > ./SEMVER
+            python3 patch_version.py $SEMVER
+      - run:
+          name: install dependencies
+          command: poetry install --only main
+      - run:
+          name: export package dependencies
+          command: ./export_dependencies.sh
+      - persist_to_workspace:
+          root: ./
+          paths:
+            - bpy_speckle
+            - patch_installer.py
+            - SEMVER
+
+  build-connector-zip:
+    docker:
+      - image: cimg/python:3.11.0
+    steps:
      - attach_workspace:
          at: ./
-      - run: 
-          name: Install specklepy with python 3.7
-          shell: powershell.exe
-          command: |
-            $pyarr=(python --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            python -m pip install --target=./modules-$pyver specklepy==$specklepy
-      - run: 
-          name: Install python 3.9 and specklepy 
-          shell: powershell.exe
-          command: |
-            choco upgrade python --version=3.9.7
-            refreshenv
-            $pyarr=(py --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            py -m pip install --target=./modules-$pyver specklepy==$specklepy
+      - run: &restore_semver
+          name: Restore Semver
+          command: SEMVER=$(cat ./SEMVER) && echo $SEMVER
      - run:
-          name: Patch
-          shell: powershell.exe
-          command:
-            | # If no tag, use 0.0.0.1 and don't make any YML (for testing only!)
-            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "0.0.1" } else { $env:CIRCLE_TAG }
-            $semver = $tag.replace("-beta","")
-            $version = "$($semver).$($env:CIRCLE_BUILD_NUM)"
-            $channel = "latest"
-            if($tag -like "*-beta") { $channel = "beta" }
-            # only create the yml if we have a tag
-            New-Item -Force "speckle-sharp-ci-tools/Installers/blender/$channel.yml" -ItemType File -Value "version: $version"
-            echo $version
-            ls
-            python patch_version.py $version
-            speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss
+          name: Package to Zip
+          command: zip -r bpy_speckle.zip bpy_speckle
      - persist_to_workspace:
          root: ./
          paths:
-            - speckle-sharp-ci-tools/Installers
-
-  install-specklepy: # due to ujson dep, we need to match the py version to the install
-    docker:
-      - image: "cimg/python:<<parameters.tag>>"
-    parameters:
-      tag:
-        default: "3.9"
-        type: string
-    steps:
-      - checkout
-      - run:
-          name: upgrade pip and install specklepy
-          command: |
-            specklepyver=$(python patch_version.py)
-            echo installing specklepy $specklepyver
-            python -m pip install --target=./modules-<<parameters.tag>> specklepy==$specklepyver
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - modules-*
-          
+            - bpy_speckle.zip
+  
  get-ci-tools: # Clones our ci tools and persists them to the workspace
    docker:
      - image: cimg/base:2021.01
    steps:
-      - run: # Could not get ssh to work, so using a personal token
+      - add_ssh_keys:
+          fingerprints:
+            - "77:64:03:93:c5:f3:1d:a6:fd:bd:fb:d1:05:56:ca:e9"
+      - run:
+          name: I know Github as a host
+          command: |
+            mkdir ~/.ssh
+            touch ~/.ssh/known_hosts
+            ssh-keyscan github.com >> ~/.ssh/known_hosts
+      - run:
          name: Clone
-          command: git clone https://$GITHUB_TOKEN@github.com/specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
+          command: git clone git@github.com:specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
+      - run:
+          command: cd speckle-sharp-ci-tools
      - persist_to_workspace:
          root: ./
          paths:
            - speckle-sharp-ci-tools

-  deploy: # Uploads all installers found to S3
-    docker:
-      - image: cimg/base:2021.01
+  build-installer-win:
+    executor:
+      name: win/default
+      shell: cmd.exe
    steps:
      - attach_workspace:
          at: ./
      - run:
-          name: List contents
-          command: ls -R speckle-sharp-ci-tools/Installers
-      - aws-s3/copy:
-          arguments: "--recursive --endpoint=https://$SPACES_REGION.digitaloceanspaces.com --acl public-read"
-          aws-access-key-id: SPACES_KEY
-          aws-region: SPACES_REGION
-          aws-secret-access-key: SPACES_SECRET
-          from: '"speckle-sharp-ci-tools/Installers/"'
-          to: s3://speckle-releases/installers/
+          name: Patch installer
+          shell: powershell.exe
+          command: python patch_installer.py (Get-Content -Raw SEMVER)
+      - run:
+          name: Create Innosetup signing cert
+          shell: powershell.exe
+          command: |
+            echo $env:PFX_B64 > "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.txt"
+            certutil -decode "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.txt" "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.pfx"
+      - run:
+          name: Installer
+          shell: cmd.exe #does not work in powershell
+          command: speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss /Sbyparam=$p
+      - persist_to_workspace:
+          root: ./
+          paths:
+            - speckle-sharp-ci-tools/Installers/blender/blender-*.exe
+
+  build-installer-mac:
+    macos:
+      xcode: 12.5.1
+    parameters:
+      runtime:
+        type: string
+      slug:
+        type: string
+      installer_path:
+        type: string
+        default: speckle-sharp-ci-tools/Mac/SpeckleBlenderInstall
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ./
+      - run:
+          name: Install mono
+          command: |
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install mono
+      # Compress build files
+      - run:
+          name: Install dotnet
+          command: curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin
+      - run: *restore_semver
+      - run:
+          name: Copy connector files to installer
+          command: |
+            mkdir -p <<parameters.installer_path >>/.installationFiles/
+            cp bpy_speckle.zip << parameters.installer_path >>/.installationFiles
+      - run:
+          name: Build Mac installer
+          command: ~/.dotnet/dotnet publish << parameters.installer_path >>/SpeckleBlenderInstall.sln -r << parameters.runtime >> -c Release
+      - run:
+          name: Zip installer
+          command: |
+            SEMVER=$(cat ./SEMVER)
+            echo $SEMVER
+            mkdir -p speckle-sharp-ci-tools/Installers/blender
+            (cd <<parameters.installer_path>>/bin/Release/net6.0/<< parameters.runtime >>/publish/ && zip -r - ./) > << parameters.slug >>-${SEMVER}.zip
+            cp << parameters.slug >>-${SEMVER}.zip speckle-sharp-ci-tools/Installers/blender/
+
+      - persist_to_workspace:
+          root: ./
+          paths:
+            - speckle-sharp-ci-tools/Installers/blender/<< parameters.slug >>*.zip
+
+  build-installer-manual:
+    docker:
+      - image: cimg/base:2021.01
+    parameters:
+      slug:
+        type: string
+        default: bpy_speckle
+    steps:
+      - attach_workspace:
+          at: ./
+      - run: *restore_semver
+      - run:
+          name: Copy zip with semver
+          command: |
+            SEMVER=$(cat ./SEMVER)
+            mkdir -p speckle-sharp-ci-tools/Installers/blender
+            cp bpy_speckle.zip speckle-sharp-ci-tools/Installers/blender/<< parameters.slug >>-${SEMVER}.zip
+      - persist_to_workspace:
+          root: ./
+          paths:
+            - speckle-sharp-ci-tools/Installers/blender/<< parameters.slug >>*.zip
+
+  deploy-connector:
+    docker:
+      - image: mcr.microsoft.com/dotnet/sdk:6.0
+    parameters:
+      file_slug:
+        type: string
+      os:
+        type: string
+      extension:
+        type: string
+      arch:
+        type: string
+        default: Any
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ./
+      - run:
+          name: Install Manager Feed CLI
+          command: dotnet tool install --global Speckle.Manager.Feed
+      - run: *restore_semver
+      - run:
+          name: Upload new version
+          # this is where the installer gets the semver baked into the file name
+          command: |
+            SEMVER=$(cat ./SEMVER)
+            echo $SEMVER
+            /root/.dotnet/tools/Speckle.Manager.Feed deploy \
+                -s blender \
+                -v ${SEMVER} \
+                -u https://releases.speckle.dev/installers/blender/<< parameters.file_slug >>-${SEMVER}.<< parameters.extension >> \
+                -o << parameters.os >> \
+                -a << parameters.arch >> \
+                -f speckle-sharp-ci-tools/Installers/blender/<< parameters.file_slug >>-${SEMVER}.<< parameters.extension >>

 workflows:
-  main:
+  build: # build the installers, but don't persist to workspace for deployment
    jobs:
+      - package-connector:
+          filters: &build_filters
+            tags:
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?(?:\.[0-9]+)?/
+      
+      - build-connector-zip:
+          requires:
+            - package-connector
+          filters: *build_filters
+
      - get-ci-tools:
-          filters:
-            tags:
-              only: /.*/
+          filters: *build_filters
+
+      - build-installer-win:
+          context: innosetup
+          name: Windows Installer Build
+          requires:
+            - package-connector
+            - get-ci-tools
+          filters: *build_filters
+
+      - deploy-connector:
+          context: do-spaces-speckle-releases
+          name: deploy-windows
+          file_slug: blender
+          os: WIN
+          arch: Any
+          extension: exe
+          requires:
+            - Manual Installer Build
+            - Windows Installer Build
+            - Mac Intel Build
+            - Mac ARM Build
+          filters: &deploy_filters
            branches:
-              only:
-                - main
-                - /ci\/.*/
-      - build-connector:
-          slug: blender
+              ignore: /.*/
+            tags:
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?(?:\.[0-9]+)?/
+
+      - build-installer-mac:
+          name: Mac ARM Build
+          slug: blender-mac-arm
+          runtime: osx-arm64
          requires:
            - get-ci-tools
-          filters:
-            tags:
-              only: /.*/
-            branches:
-              only:
-                - main
-                - /ci\/.*/
-      - deploy:
+            - build-connector-zip
+          filters: *build_filters
+
+      - deploy-connector:
+          context: do-spaces-speckle-releases
+          name: deploy-mac-arm
+          file_slug: blender-mac-arm
+          os: OSX
+          arch: Arm
+          extension: zip
+          requires:
+            - Manual Installer Build
+            - Windows Installer Build
+            - Mac Intel Build
+            - Mac ARM Build
+          filters: *deploy_filters
+
+      - build-installer-mac:
+          name: Mac Intel Build
+          slug: blender-mac-intel
+          runtime: osx-x64
          requires:
            - get-ci-tools
-            - build-connector
-          filters:
-            tags:
-              only: /[0-9]+(\.[0-9]+)*/
-            branches:
-              ignore: /.*/ # For testing only! /ci\/.*/
+            - build-connector-zip
+          filters: *build_filters
+
+      - deploy-connector:
+          context: do-spaces-speckle-releases
+          name: deploy-mac-intel
+          file_slug: blender-mac-intel
+          os: OSX
+          arch: Intel
+          extension: zip
+          requires:
+            - Manual Installer Build
+            - Windows Installer Build
+            - Mac Intel Build
+            - Mac ARM Build
+          filters: *deploy_filters
+
+      - build-installer-manual:
+          name: Manual Installer Build
+          requires:
+            - get-ci-tools
+            - build-connector-zip
+          filters: *build_filters
+
+      - deploy-connector:
+          context: do-spaces-speckle-releases
+          name: deploy-manual
+          file_slug: bpy_speckle
+          os: Any
+          arch: Any
+          extension: zip
+          requires:
+            - Manual Installer Build
+            - Windows Installer Build
+            - Mac Intel Build
+            - Mac ARM Build
+          filters: *deploy_filters
@@ -6,73 +6,7 @@ on:

 jobs:
  update_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          
-          echo "$PROJECT_ID"
-          echo "$STATUS_FIELD_ID"
-          
-          echo 'DONE_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .settings | fromjson | .options[] | select(.name== "Done") | .id' project_data.json) >> $GITHUB_ENV
-          echo "$DONE_ID"
-
-      - name: Add Issue to project #it's already in the project, but we do this to get its node id!
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV
-          
-      - name: Update Status
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $status:ID!, $id:ID!, $value:String!) {
-              set_status: updateProjectNextItemField(
-                input: {
-                  projectId: $project
-                  itemId: $id
-                  fieldId: $status
-                  value: $value
-                }
-              ) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f status=$STATUS_FIELD_ID -f id=$ITEM_ID -f value=${{ env.DONE_ID }}
-          
+    uses: specklesystems/github-actions/.github/workflows/project-add-issue.yml@main
+    secrets: inherit
+    with:
+      issue-id: ${{ github.event.issue.node_id }}
@@ -6,45 +6,7 @@ on:

 jobs:
  track_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-     
-      - name: Add Issue to project
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV
+    uses: specklesystems/github-actions/.github/workflows/project-add-issue.yml@main
+    secrets: inherit
+    with:
+      issue-id: ${{ github.event.issue.node_id }}
@@ -10,4 +10,7 @@ __pycache__/
 # dev
 .venv
 Installers/
-modules/
+modules/
+.tool-versions
+requirements.txt
+SEMVER
@@ -3,7 +3,7 @@
  Speckle | Blender
 </h1>
 <h3 align="center">
-    Connector for Blender 2.92 & 2.93
+    Connector for Blender
 </h3>
 <p align="center"><b>Speckle</b> is the data infrastructure for the AEC industry.</p><br/>

@@ -91,4 +91,4 @@ The Speckle Community hangs out on [the forum](https://discourse.speckle.works),
 Unless otherwise described, the code in this repository is licensed under the Apache-2.0 License. Please note that some modules, extensions or code herein might be otherwise licensed. This is indicated either in the root of the containing folder under a different license file, or in the respective file's header. If you have any questions, don't hesitate to get in touch with us via [email](mailto:hello@speckle.systems).

 ## Notes
-SpeckleBlender is written and maintained by [Tom Svilans](http://tomsvilans.com) ([Github](https://github.com/tsvilans)).
+Thanks to [Tom Svilans](http://tomsvilans.com) ([Github](https://github.com/tsvilans)) for the original v1 contribution!
@@ -1,25 +1,15 @@
-# MIT License
+import bpy
+from bpy_speckle.installer import ensure_dependencies

-# Copyright (c) 2018-2021 Tom Svilans
+ensure_dependencies(f"Blender {bpy.app.version[0]}.{bpy.app.version[1]}")

-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
+from specklepy.logging import metrics

+from bpy_speckle.ui import *
+from bpy_speckle.properties import *
+from bpy_speckle.operators import *
+from bpy_speckle.callbacks import *
+from bpy.app.handlers import persistent

 bl_info = {
    "name": "SpeckleBlender 2.0",
@@ -33,45 +23,26 @@ bl_info = {
    "category": "Scene",
 }

-import bpy

-"""
-Import PySpeckle and attempt install if not found
-"""
-
-try:
-    import specklepy
-except ModuleNotFoundError as error:
-    print("Speckle not found.")
-    # TODO: Implement automatic installation of speckle and dependencies
-    # to the local Blender module folder
-
-    # from .install_dependencies import install_dependencies
-    # install_dependencies()

 """
 Import SpeckleBlender classes
 """

-from specklepy.api.client import SpeckleClient  # , SpeckleCache
-from specklepy.logging import metrics
-
-from bpy_speckle.ui import *
-from bpy_speckle.properties import *
-from bpy_speckle.operators import *
-from bpy_speckle.callbacks import *
-from bpy.app.handlers import persistent
-
 """
 Add load handler to initialize Speckle when 
 loading a Blender file
 """

-
@persistent
 def load_handler(dummy):
-    bpy.ops.speckle.users_load()
-
+    pass
+    # Calling users_load is an expensive operation, one that force users to wait a good 10s every time blender loads.
+    # Until we can do this non-blocking, we will make the user hit the refresh button each time.
+    #bpy.ops.speckle.users_load()
+    
+    # Instead, we shall just reset the user selection to an uninitiailised state
+    bpy.ops.speckle.users_reset()

 """
 Permanent handle on callbacks
@@ -95,7 +66,7 @@ def register():
    for cls in speckle_classes:
        register_class(cls)

-    metrics.set_host_app("Blender")
+    metrics.set_host_app("blender", f"blender {bpy.app.version_string}")

    """
    Register all new properties
@@ -0,0 +1,120 @@
+from typing import Dict, Optional, Tuple, Union
+import bpy
+from bpy.types import Object, Collection, ID
+from specklepy.objects.base import Base
+from bpy_speckle.functions import _report
+from specklepy.objects.graph_traversal.commit_object_builder import CommitObjectBuilder, ROOT
+from specklepy.objects import Base
+from specklepy.objects.other import Collection as SCollection
+from attrs import define
+
+ELEMENTS = "elements"
+
+def _id(native_object: ID) -> str:
+    #NOTE: to avoid naming collisions, we prefix collections and objects differently
+    return f"{type(native_object).__name__}:{native_object.name_full}" 
+
+def _try_id(native_object: Optional[Union[Collection, Object]]) -> Optional[str]:
+    return _id(native_object) if native_object else None
+
+def convert_collection_to_speckle(col: Collection) -> SCollection:
+    converted_collection = SCollection(name = col.name_full, collectionType = "Blender Collection", elements = [])
+    converted_collection.applicationId = _id(col)
+
+    color_tag = col.color_tag
+    if color_tag and color_tag != "NONE":
+        converted_collection["colorTag"] = col.color_tag
+
+    return converted_collection
+
+@define(slots=True)
+class BlenderCommitObjectBuilder(CommitObjectBuilder[Object]):
+
+    _collections: Dict[str, SCollection]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._collections = {}
+
+    def include_object(self, conversion_result: Base, native_object: Object) -> None:
+
+        # Set the Child -> Parent relationships
+        parent = native_object.parent
+        
+        parent_collections: Tuple[Collection] = native_object.users_collection # type: ignore 
+        parent_collection = parent_collections[0] if len(parent_collections) > 0 else None #NOTE: we don't support objects appearing in more than one collection, for now, we will just take the zeroth one
+        
+        app_id = _id(native_object)
+        conversion_result.applicationId = app_id
+        self.converted[app_id] = conversion_result
+
+        # in order or priority, direct parent, direct parent collection, root
+        self.set_relationship(app_id, (_try_id(parent), ELEMENTS), (_try_id(parent_collection), ELEMENTS), (ROOT, ELEMENTS))
+        # if parent_collection:
+        #     self._include_collection(parent_collection)
+
+    def ensure_collection(self, col: Collection) -> SCollection:
+        id = _id(col)
+        if id in self._collections:
+            return self._collections[id] # collection already converted!
+
+         # Set the Parent -> Children relationships
+        for c in col.children:
+            #NOTE: There's no falling back to the grandparent, if the direct parent collection wasn't converted, then we we fallback to the root
+            self.set_relationship(_id(c), (id, ELEMENTS), (ROOT, ELEMENTS)) 
+
+        # Set Child -> Parent relationship
+        # parent = self.find_collection_parent(col)
+        # self.set_relationship(id, (_try_builder_id(parent), ELEMENTS), (ROOT, ELEMENTS)) 
+
+        converted_collection = convert_collection_to_speckle(col)
+        self.converted[id] = converted_collection
+        self._collections[id] = converted_collection
+
+        return converted_collection
+
+    def build_commit_object(self, root_commit_object: Base) -> None:
+        assert(root_commit_object.applicationId in self.converted)
+
+        # Create all collections
+        root_col = self.ensure_collection(bpy.context.scene.collection)
+        root_col.collectionType = "Scene Collection"
+        for col in bpy.context.scene.collection.children_recursive: #type: ignore
+            self.ensure_collection(col)
+
+        objects_to_build = set(self.converted.values())
+        objects_to_build.remove(root_commit_object)
+
+        self.apply_relationships(objects_to_build, root_commit_object)
+
+        assert(isinstance(root_commit_object, SCollection))
+        # Kill unused collections
+
+        def should_remove_unuseful_collection(col: SCollection) -> bool: #TODO: this maybe could be optimised
+            elements = col.elements
+            if not elements: return True
+
+            should_remove_this_col = True
+
+            i = 0
+            while i < len(elements):
+                c = elements[i]
+                if not isinstance(c, SCollection): 
+                    # col has objects (c)
+                    should_remove_this_col = False
+                    i += 1
+                    continue
+
+                if should_remove_unuseful_collection(c):
+                    # c is not useful, kill it
+                    del elements[i]
+                else:
+                    # col has a child (c) with objects
+                    should_remove_this_col = False
+                    i += 1
+                    continue
+        
+            return should_remove_this_col
+
+        if should_remove_unuseful_collection(root_commit_object):
+            _report("WARNING: Only empty collections have been converted!") #TODO: consider raising exception here, to halt the send operation
@@ -1,4 +1,7 @@
 """
 Permanent handle on all user clients
 """
-speckle_clients = []
+from specklepy.core.api.client import SpeckleClient
+
+
+speckle_clients: list[SpeckleClient] = []
@@ -1,27 +0,0 @@
-from bpy_speckle.convert.to_native import convert_to_native
-
-
-def get_speckle_subobjects(attr, scale, name):
-    subobjects = []
-    for key in attr.keys():
-        if isinstance(attr[key], dict):
-            subtype = attr[key].get("type", None)
-            if subtype:
-                name = f"{name}.{key}"
-                subobject = convert_to_native(attr[key], name)
-
-                subobjects.append(subobject)
-                props = attr[key].get("properties", None)
-                if props:
-                    subobjects.extend(get_speckle_subobjects(props, scale, name))
-        elif hasattr(attr[key], "type"):
-            subtype = attr[key].type
-            if subtype:
-                name = "{}.{}".format(name, key)
-                subobject = convert_to_native(attr[key], name)
-
-                subobjects.append(subobject)
-                props = attr[key].get("properties", None)
-                if props:
-                    subobjects.extend(get_speckle_subobjects(props, scale, name))
-    return subobjects
@@ -0,0 +1,22 @@
+IGNORED_PROPERTY_KEYS = {
+    "id",
+    "elements",
+    "displayMesh",
+    "displayValue",
+    "speckle_type",
+    "parameters",
+    "faces",
+    "colors",
+    "vertices",
+    "renderMaterial",
+    "textureCoordinates",
+    "totalChildrenCount"
+}
+
+DISPLAY_VALUE_PROPERTY_ALIASES = {"displayValue", "@displayValue"}
+ELEMENTS_PROPERTY_ALIASES = {"elements", "@elements"}
+
+OBJECT_NAME_MAX_LENGTH = 62
+SPECKLE_ID_LENGTH = 32
+OBJECT_NAME_SPECKLE_SEPARATOR = " -- "
+OBJECT_NAME_NUMERAL_SEPARATOR = '.'
@@ -1,114 +1,184 @@
+from typing import Dict, Iterable, List, Optional, Tuple, Union, cast
 import bpy
-from specklepy.objects.geometry import Mesh, Curve, Interval, Box, Point, Polyline
-from specklepy.objects.other import *
-from bpy_speckle.functions import _report
+from bpy.types import (
+    Depsgraph, 
+    MeshPolygon, 
+    Object, 
+    Curve as NCurve,
+    Mesh as NMesh,
+    Camera as NCamera,
+)
+from deprecated import deprecated
+from mathutils.geometry import interpolate_bezier
+from mathutils import (
+    Matrix as MMatrix,
+    Vector as MVector,
+)
+from specklepy.objects import Base
+from specklepy.objects.other import BlockInstance, BlockDefinition, RenderMaterial, Transform
+from specklepy.objects.geometry import (
+     Mesh, Curve, Interval, Box, Point, Vector, Polyline,
+)
+from bpy_speckle.blender_commit_object_builder import BlenderCommitObjectBuilder
+from bpy_speckle.convert.constants import OBJECT_NAME_SPECKLE_SEPARATOR, SPECKLE_ID_LENGTH
 from bpy_speckle.convert.util import (
+    ConversionSkippedException,
    get_blender_custom_properties,
    make_knots,
+    nurb_make_curve,
    to_argb_int,
 )
-
-UNITS = "m"
-
-CAN_CONVERT_TO_SPECKLE = ("MESH", "CURVE", "EMPTY")
+from bpy_speckle.functions import _report


-def convert_to_speckle(blender_object, scale, desgraph=None):
-    blender_type = blender_object.type
+Units: str = "m" # The desired final units to send
+UnitsScale: float = 1 # The scale factor conversions need to apply to position data to get to the desired units
+
+CAN_CONVERT_TO_SPECKLE = ("MESH", "CURVE", "EMPTY", "CAMERA")
+
+
+def convert_to_speckle(raw_blender_object: Object, units_scale: float, units: str, depsgraph: Optional[Depsgraph]) -> Base:
+    """
+    Converts supported 1 blender objects to 1 speckle object (potentially with children)
+    :param raw_blender_object: the blender object (unevaluated by a Depsgraph) to convert
+    :param units_scale: The scale factor conversions need to apply to position data to get to the desired units
+    :param units: The desired final units to send
+    :param depsgraph: Optional depsgraph if provided will evaluate modifiers on geometry data
+    :return: The Converted blender object
+    """
+    global Units, UnitsScale
+    Units = units
+    UnitsScale = units_scale
+    
+    blender_type = raw_blender_object.type
    if blender_type not in CAN_CONVERT_TO_SPECKLE:
-        return
+        raise ConversionSkippedException(f"Objects of type {blender_type} are not supported")

-    speckle_objects = []
-    speckle_material = material_to_speckle(blender_object)
-    if desgraph:
-        blender_object = blender_object.evaluated_get(desgraph)
-    converted = None
+    blender_object = cast(Object, (
+        raw_blender_object.evaluated_get(depsgraph)
+        if depsgraph
+        else raw_blender_object
+        ))
+
+    converted: Optional[Base] = None
    if blender_type == "MESH":
-        converted = mesh_to_speckle(blender_object, blender_object.data, scale)
+        converted = mesh_to_speckle(blender_object, cast(NMesh, blender_object.data))
    elif blender_type == "CURVE":
-        converted = icurve_to_speckle(blender_object, blender_object.data, scale)
+        converted = curve_to_speckle(blender_object, cast(NCurve, blender_object.data))
    elif blender_type == "EMPTY":
-        converted = empty_to_speckle(blender_object, scale)
+        converted = empty_to_speckle(blender_object)
+    elif blender_type == "CAMERA":
+        converted = camera_to_speckle_view(blender_object, cast(NCamera, blender_object.data))
    if not converted:
-        return None
+        raise Exception("Conversion returned None")

-    if isinstance(converted, list):
-        speckle_objects.extend([c for c in converted if c != None])
-    else:
-        speckle_objects.append(converted)
-    for so in speckle_objects:
-        so.properties = get_blender_custom_properties(blender_object)
-        so.applicationId = so.properties.pop("applicationId", None)
+    converted["properties"] = get_blender_custom_properties(raw_blender_object) #NOTE: Depsgraph copies don't have custom properties so we use the raw version

-        if speckle_material:
-            so["renderMaterial"] = speckle_material
+    # Set object transform #TODO: this could be deprecated once we add proper geometry instancing support
+    if blender_type != "EMPTY": 
+        converted["properties"]["transform"] = transform_to_speckle(
+            blender_object.matrix_world
+        )

-        # Set object transform
-        if blender_type != "EMPTY":
-            so.properties["transform"] = transform_to_speckle(
-                blender_object.matrix_world
-            )
+    return converted

-    return speckle_objects
+def mesh_to_speckle(blender_object: Object, data: bpy.types.Mesh) -> Base:
+    b = Base()
+    b["name"] = to_speckle_name(blender_object)
+    b["@displayValue"] = mesh_to_speckle_meshes(blender_object, data)
+    return b
+
+def mesh_to_speckle_meshes(blender_object: Object, data: bpy.types.Mesh) -> List[Mesh]:
+
+    # Categorise polygons by material index
+    submesh_data: Dict[int, List[MeshPolygon]] = {}
+
+    for p in data.polygons:
+        if p.material_index not in submesh_data:
+            submesh_data[p.material_index] = []
+        submesh_data[p.material_index].append(p)
+
+    transform = cast(MMatrix, blender_object.matrix_world)
+    scaled_vertices = [tuple(transform @ x.co * UnitsScale) for x in data.vertices] # type: ignore
+
+    # Create Speckle meshes for each material
+    submeshes = []
+    index_counter = 0
+    for i in submesh_data:
+        index_mapping: Dict[int, int] = {}
+
+        #Loop through each polygon, and map indices to their new index in m_verts
+    
+        mesh_area = 0
+        m_verts: List[float] = []
+        m_faces: List[int] = []
+        m_texcoords: List[float] = []
+        for face in submesh_data[i]:
+            u_indices = face.vertices
+            m_faces.append(len(u_indices))
+
+            mesh_area += face.area
+            for u_index in u_indices:
+                if u_index not in index_mapping:
+                    # Create mapping between index in blender mesh, and new index in speckle submesh
+                    index_mapping[u_index] = len(m_verts) // 3
+                    vert = scaled_vertices[u_index]
+                    m_verts.append(vert[0])
+                    m_verts.append(vert[1])
+                    m_verts.append(vert[2])
+                
+                if data.uv_layers.active:
+                    vt = data.uv_layers.active.data[index_counter]
+                    uv = cast(MVector, vt.uv)
+                    m_texcoords.extend([uv.x, uv.y])
+
+                m_faces.append(index_mapping[u_index])
+                index_counter += 1
+
+        speckle_mesh = Mesh(
+            vertices=m_verts,
+            faces=m_faces,
+            colors=[],
+            textureCoordinates=m_texcoords,
+            units=Units,
+            area = mesh_area,
+            bbox=Box(area=0.0, volume=0.0),
+        )
+        
+        if i < len(data.materials):
+            material = data.materials[i]
+            if material is not None:
+                speckle_mesh["renderMaterial"] = material_to_speckle(material)
+        submeshes.append(speckle_mesh)           
+
+    return submeshes


-def mesh_to_speckle(blender_object, data, scale=1.0):
-    if data.loop_triangles is None or len(data.loop_triangles) < 1:
-        data.calc_loop_triangles()
-
-    mat = blender_object.matrix_world
-
-    verts = [tuple(mat @ x.co * scale) for x in data.vertices]
-
-    faces = [p.vertices for p in data.polygons]
-    unit_system = bpy.context.scene.unit_settings.system
-
-    sm = Mesh(
-        name=blender_object.name,
-        vertices=list(sum(verts, ())),
-        faces=[],
-        colors=[],
-        textureCoordinates=[],
-        units="m" if unit_system == "METRIC" else "ft",
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-    if data.uv_layers.active:
-        for vt in data.uv_layers.active.data:
-            sm.textureCoordinates.extend([vt.uv.x, vt.uv.y])
-
-    for f in faces:
-        n = len(f)
-        if n == 3:
-            sm.faces.append(0)
-        elif n == 4:
-            sm.faces.append(1)
-        else:
-            sm.faces.append(n)
-        sm.faces.extend(f)
-
-    return [sm]
-
-
-def bezier_to_speckle(matrix, spline, scale, name=None):
+def bezier_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Curve:
    degree = 3
    closed = spline.use_cyclic_u
-
-    points = []
+    points: List[Tuple[MVector]] = []
    for i, bp in enumerate(spline.bezier_points):
        if i > 0:
-            points.append(tuple(matrix @ bp.handle_left * scale))
-        points.append(tuple(matrix @ bp.co * scale))
+            points.append(tuple(matrix @ bp.handle_left * UnitsScale)) # type: ignore
+        points.append(tuple(matrix @ bp.co * UnitsScale)) # type: ignore
        if i < len(spline.bezier_points) - 1:
-            points.append(tuple(matrix @ bp.handle_right * scale))
+            points.append(tuple(matrix @ bp.handle_right * UnitsScale)) # type: ignore

    if closed:
-        points.append(tuple(matrix @ spline.bezier_points[-1].handle_right * scale))
-        points.append(tuple(matrix @ spline.bezier_points[0].handle_left * scale))
-        points.append(tuple(matrix @ spline.bezier_points[0].co * scale))
-
+        points.extend(
+            (
+                tuple(matrix @ spline.bezier_points[-1].handle_right * UnitsScale), # type: ignore
+                tuple(matrix @ spline.bezier_points[0].handle_left * UnitsScale), # type: ignore
+                tuple(matrix @ spline.bezier_points[0].co * UnitsScale), # type: ignore
+            )
+        )
+    
    num_points = len(points)

+    flattened_points = []
+    for row in points: flattened_points.extend(row)
+
    knot_count = num_points + degree - 1
    knots = [0] * knot_count

@@ -121,93 +191,187 @@ def bezier_to_speckle(matrix, spline, scale, name=None):
        name=name,
        degree=degree,
        closed=spline.use_cyclic_u,
-        periodic=spline.use_cyclic_u,
-        points=list(sum(points, ())),  # magic (flatten list of tuples)
+        periodic= not spline.use_endpoint_u,
+        points=flattened_points,
        weights=[1] * num_points,
        knots=knots,
-        rational=False,
+        rational=True,
        area=0,
        volume=0,
        length=length,
        domain=domain,
-        units=UNITS,
+        units=Units,
        bbox=Box(area=0.0, volume=0.0),
+        displayValue = bezier_to_speckle_polyline(matrix, spline, length),
    )


-def nurbs_to_speckle(matrix, spline, scale, name=None):
-    knots = make_knots(spline)
-    points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
+def nurbs_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Curve:
+
    degree = spline.order_u - 1
+    knots = make_knots(spline)

    length = spline.calc_length()
    domain = Interval(start=0, end=length, totalChildrenCount=0)

+    weights = [pt.weight for pt in spline.points]
+    is_rational = all(w == weights[0] for w in weights)
+
+    points = [tuple(matrix @ pt.co.xyz * UnitsScale) for pt in spline.points] # type: ignore
+
+    flattened_points = []
+    for row in points: flattened_points.extend(row)
+
+    if spline.use_cyclic_u:
+        for i in range(0, degree * 3, 3):
+            # Rhino expects n + degree number of points (for closed curves). So we need to add an extra point for each degree
+            flattened_points.append(flattened_points[i + 0])
+            flattened_points.append(flattened_points[i + 1])
+            flattened_points.append(flattened_points[i + 2])
+        
+        for i in range(0, degree):
+            weights.append(weights[i])
+
    return Curve(
        name=name,
        degree=degree,
        closed=spline.use_cyclic_u,
-        periodic=spline.use_cyclic_u,
-        points=list(sum(points, ())),  # magic (flatten list of tuples)
-        weights=[pt.weight for pt in spline.points],
+        periodic= not spline.use_endpoint_u,
+        points=flattened_points,
+        weights=weights,
        knots=knots,
-        rational=False,
+        rational=is_rational, 
        area=0,
        volume=0,
        length=length,
        domain=domain,
-        units=UNITS,
+        units=Units,
        bbox=Box(area=0.0, volume=0.0),
+        displayValue=nurbs_to_speckle_polyline(matrix, spline, length),
    )

+def nurbs_to_speckle_polyline(matrix: MMatrix, spline: bpy.types.Spline, length: Optional[float] = None) -> Polyline:
+    """
+    Samples a nurbs curve with resolution_u creating a polyline
+    """
+    points: List[float] = []
+    sampled_points = nurb_make_curve(spline, spline.resolution_u, 3)
+    for i in range(0, len(sampled_points), 3):
+        scaled_point = cast(Vector, matrix @ MVector((
+        sampled_points[i + 0],
+        sampled_points[i + 1],
+        sampled_points[i + 2])) * UnitsScale)

-def poly_to_speckle(matrix, spline, scale, name=None):
-    points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
+        points.append(scaled_point.x)
+        points.append(scaled_point.y)
+        points.append(scaled_point.z)
+        
+    length = length or spline.calc_length()
+    domain = Interval(start=0, end=length, totalChildrenCount=0)
+    return Polyline(value=points, closed = spline.use_cyclic_u, domain=domain, area=0, len=length)
+
+
+#Inspired by https://blender.stackexchange.com/a/689 (CC BY-SA 3.0) 
+def bezier_to_speckle_polyline(matrix: MMatrix, spline: bpy.types.Spline, length: Optional[float] = None) -> Optional[Polyline]:
+    """
+    Samples a Bézier curve with resolution_u creating a polyline
+    """
+    segments = len(spline.bezier_points)
+    if segments < 2: return None
+
+    R = spline.resolution_u + 1
+
+    points = []
+    if not spline.use_cyclic_u:
+        segments -= 1
+    
+    points: List[float] = []
+    for i in range(segments):
+        inext = (i + 1) % len(spline.bezier_points)
+
+        knot1 = spline.bezier_points[i].co
+        handle1 = spline.bezier_points[i].handle_right
+        handle2 = spline.bezier_points[inext].handle_left
+        knot2 = spline.bezier_points[inext].co
+
+        _points = interpolate_bezier(knot1, handle1, handle2, knot2, R)
+        for p in _points:
+            scaled_point = matrix @ p * UnitsScale
+            points.append(scaled_point.x)
+            points.append(scaled_point.y)
+            points.append(scaled_point.z)
+
+    length = length or spline.calc_length()
+    domain = Interval(start=0, end=length, totalChildrenCount=0)
+    return Polyline(value=points, closed = spline.use_cyclic_u, domain=domain, area=0, len=length)
+
+_QUICK_TEST_NAME_LENGTH = SPECKLE_ID_LENGTH + len(OBJECT_NAME_SPECKLE_SEPARATOR)
+
+def to_speckle_name(blender_object: bpy.types.ID) -> str:
+    does_name_contain_id = len(blender_object.name) > _QUICK_TEST_NAME_LENGTH and OBJECT_NAME_SPECKLE_SEPARATOR in blender_object.name
+    if does_name_contain_id:
+        return blender_object.name.rsplit(OBJECT_NAME_SPECKLE_SEPARATOR, 1)[0]
+    else:
+        return blender_object.name
+
+def poly_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Polyline:
+    points = [tuple(matrix @ pt.co.xyz * UnitsScale) for pt in spline.points] # type: ignore
+
+    flattened_points = []
+    for row in points: flattened_points.extend(row)

    length = spline.calc_length()
    domain = Interval(start=0, end=length, totalChildrenCount=0)
    return Polyline(
        name=name,
-        closed=spline.use_cyclic_u,
-        value=list(sum(points, ())),  # magic (flatten list of tuples)
+        closed=bool(spline.use_cyclic_u),
+        value=list(flattened_points),
        length=length,
        domain=domain,
        bbox=Box(area=0.0, volume=0.0),
        area=0,
-        units=UNITS,
+        units=Units,
    )


-def icurve_to_speckle(blender_object, data, scale=1.0):
-    UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
+def curve_to_speckle(blender_object: Object, data: bpy.types.Curve) -> Base:
+    b = Base()
+    (meshes, curves) = curve_to_speckle_geometry(blender_object, data)
+    if meshes:
+        b["@displayValue"] = meshes

-    if blender_object.type != "CURVE":
-        return None
+    b["name"] = to_speckle_name(blender_object)
+    b["@elements"] = curves
+    return b

-    blender_object = blender_object.evaluated_get(bpy.context.view_layer.depsgraph)
+def curve_to_speckle_geometry(blender_object: Object, data: bpy.types.Curve) -> Tuple[List[Mesh], List[Base]]:
+    assert(blender_object.type == "CURVE")

-    mat = blender_object.matrix_world
+    blender_object = cast(Object, blender_object.evaluated_get(bpy.context.view_layer.depsgraph))

-    curves = []
+    matrix = cast(MMatrix, blender_object.matrix_world)

+    meshes: List[Mesh] = []
+    curves: List[Base] = []
+
+    #TODO: Could we support this better?
    if data.bevel_mode == "OBJECT" and data.bevel_object != None:
-        mesh = mesh_to_speckle(blender_object, blender_object.to_mesh(), scale)
-        curves.extend(mesh)
+        meshes = mesh_to_speckle_meshes(blender_object, blender_object.to_mesh())

    for spline in data.splines:
        if spline.type == "BEZIER":
-            curves.append(bezier_to_speckle(mat, spline, scale, blender_object.name))
+            curves.append(bezier_to_speckle(matrix, spline, to_speckle_name(blender_object)))

        elif spline.type == "NURBS":
-            curves.append(nurbs_to_speckle(mat, spline, scale, blender_object.name))
+            curves.append(nurbs_to_speckle(matrix, spline, to_speckle_name(blender_object)))

        elif spline.type == "POLY":
-            curves.append(poly_to_speckle(mat, spline, scale, blender_object.name))
+            curves.append(poly_to_speckle(matrix, spline, to_speckle_name(blender_object)))

-    return curves
+    return (meshes, curves)

-
-def ngons_to_speckle_polylines(blender_object, data, scale=1.0):
+@deprecated
+def ngons_to_speckle_polylines(blender_object: Object, data: bpy.types.Mesh) -> Optional[List[Polyline]]:
    UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"

    if blender_object.type != "MESH":
@@ -220,13 +384,13 @@ def ngons_to_speckle_polylines(blender_object, data, scale=1.0):
    for i, poly in enumerate(data.polygons):
        value = []
        for v in poly.vertices:
-            value.extend(mat @ verts[v].co * scale)
+            value.extend(mat @ verts[v].co * UnitsScale) # type: ignore

        domain = Interval(start=0, end=1)
        poly = Polyline(
            name="{}_{}".format(blender_object.name, i),
            closed=True,
-            value=value,  # magic (flatten list of tuples)
+            value=value,
            length=0,
            domain=domain,
            bbox=Box(area=0.0, volume=0.0),
@@ -239,79 +403,129 @@ def ngons_to_speckle_polylines(blender_object, data, scale=1.0):
    return polylines


-def material_to_speckle(blender_object) -> RenderMaterial:
-    """Create and return a render material from a blender object"""
-    if not getattr(blender_object.data, "materials", None):
-        return
-
-    blender_mat = blender_object.data.materials[0]
-    if not blender_mat:
-        return
-
+def material_to_speckle(blender_mat: bpy.types.Material) -> RenderMaterial:
    speckle_mat = RenderMaterial()
    speckle_mat.name = blender_mat.name

-    if blender_mat.use_nodes is True and blender_mat.node_tree.nodes.get(
-        "Principled BSDF"
-    ):
-        inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-        speckle_mat.diffuse = to_argb_int(inputs["Base Color"].default_value)
-        speckle_mat.emissive = to_argb_int(inputs["Emission"].default_value)
-        speckle_mat.roughness = inputs["Roughness"].default_value
-        speckle_mat.metalness = inputs["Metallic"].default_value
-        speckle_mat.opacity = inputs["Alpha"].default_value
+    if blender_mat.use_nodes:
+        if blender_mat.node_tree.nodes.get("Principled BSDF"):
+            inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
+            speckle_mat.diffuse = to_argb_int(inputs["Base Color"].default_value) # type: ignore
+            speckle_mat.emissive = to_argb_int(inputs["Emission"].default_value) # type: ignore
+            speckle_mat.roughness = inputs["Roughness"].default_value # type: ignore
+            speckle_mat.metalness = inputs["Metallic"].default_value # type: ignore
+            speckle_mat.opacity = inputs["Alpha"].default_value # type: ignore
+            return speckle_mat
+        elif blender_mat.node_tree.nodes.get("Diffuse BSDF"):
+            inputs = blender_mat.node_tree.nodes["Diffuse BSDF"].inputs
+            speckle_mat.diffuse = to_argb_int(inputs["Color"].default_value) # type: ignore
+            speckle_mat.roughness = inputs["Roughness"].default_value # type: ignore
+            return speckle_mat
+        #TODO: Support more shaders

-    else:
-        speckle_mat.diffuse = to_argb_int(blender_mat.diffuse_color)
-        speckle_mat.metalness = blender_mat.metallic
-        speckle_mat.roughness = blender_mat.roughness
+    # fallback to standard material props
+    speckle_mat.diffuse = to_argb_int(blender_mat.diffuse_color) # type: ignore
+    speckle_mat.metalness = blender_mat.metallic
+    speckle_mat.roughness = blender_mat.roughness

    return speckle_mat

+def camera_to_speckle_view(blender_object: Object, data: NCamera) -> Base:
+    if data.type != 'PERSP':
+        raise Exception(f"Cameras of type {data.type} are not currently supported")
+    
+    matrix = cast(MMatrix, blender_object.matrix_world)
+    up = matrix.col[1].xyz # type: ignore
+    forwards = -matrix.col[2].xyz # type: ignore
+    translation = matrix.translation

-def transform_to_speckle(blender_transform, scale=1.0):
-    units = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-    value = [y for x in blender_transform for y in x]
+    view = Base.of_type("Objects.BuiltElements.View:Objects.BuiltElements.View3D") #HACK: views are not in specklepy yet!
+    view.name = to_speckle_name(blender_object)
+    view.origin = vector_to_speckle_point(translation)
+    view.upDirection = vector_to_speckle(up)
+    view.forwardDirection = vector_to_speckle(forwards)
+    view.target = vector_to_speckle_point(forwards) #TODO: do these need to be scaled?
+    view.units = Units
+    view.isOrthogonal = False
+    return view
+
+def vector_to_speckle_point(xyz: MVector) -> Point:
+    return Point(
+        x = xyz.x * UnitsScale,
+        y = xyz.y * UnitsScale,
+        z = xyz.z * UnitsScale,
+        units = Units,
+        )
+
+def vector_to_speckle(xyz: MVector) -> Vector:
+    return Vector(
+        x = xyz.x * UnitsScale,
+        y = xyz.y * UnitsScale,
+        z = xyz.z * UnitsScale,
+        units = Units,
+        )
+
+def transform_to_speckle(blender_transform: Union[Iterable[Iterable[float]], MMatrix]) -> Transform:
+    iterable_transform = cast(Iterable[Iterable[float]], blender_transform) #NOTE: Matrix are iterable, even if type hinting says they are not
+    value = [y for x in iterable_transform for y in x]
    # scale the translation
    for i in (3, 7, 11):
-        value[i] *= scale
+        value[i] *= UnitsScale

-    return Transform(value=value, units=units)
+    return Transform(value=value, units=Units)


-def block_def_to_speckle(blender_definition, scale=1.0):
-    geometry = []
+def block_def_to_speckle(blender_definition: bpy.types.Collection) -> BlockDefinition:
+    geometryBuilder = BlenderCommitObjectBuilder()
    for geo in blender_definition.objects:
-        geometry.extend(convert_to_speckle(geo, scale))
+        try:
+            c = convert_to_speckle(geo, UnitsScale, Units, None)
+            geometryBuilder.include_object(c, geo)
+        except ConversionSkippedException as ex:
+            _report(f"Skipped converting '{geo.name_full}' inside collection instance: '{ex}")
+        except Exception as ex:
+            _report(f"Failed to converted '{geo.name_full}' inside collection instance: '{ex}'")
+
+    dummyRoot = Base()
+    geometryBuilder.apply_relationships(geometryBuilder.converted.values(), dummyRoot)
+
    block_def = BlockDefinition(
-        units=UNITS,
-        name=blender_definition.name,
-        geometry=geometry,
-        basePoint=Point(units=UNITS),
+        units=Units,
+        name=to_speckle_name(blender_definition),
+        geometry=dummyRoot["@elements"],
+        basePoint=Point(units=Units),
    )
-    blender_props = get_blender_custom_properties(blender_definition)
-    block_def.applicationId = blender_props.pop("applicationId", None)
+    # blender_props = get_blender_custom_properties(blender_definition)
+    # block_def.applicationId = blender_props.pop("applicationId", None) #TODO: remove?
    return block_def


-def block_instance_to_speckle(blender_instance, scale=1.0):
+def block_instance_to_speckle(blender_instance: Object) -> BlockInstance:
    return BlockInstance(
        blockDefinition=block_def_to_speckle(
-            blender_instance.instance_collection, scale
+            blender_instance.instance_collection
        ),
        transform=transform_to_speckle(blender_instance.matrix_world),
-        name=blender_instance.name,
-        units=UNITS,
+        name=to_speckle_name(blender_instance),
+        units=Units,
    )


-def empty_to_speckle(blender_object, scale=1.0):
+def empty_to_speckle(blender_object: Object) -> Union[BlockInstance, Base]:
    # probably an instance collection (block) so let's try it
-    try:
-        geo = blender_object.instance_collection.objects.items()
-        return block_instance_to_speckle(blender_object, scale)
-    except AttributeError as err:
-        _report(
-            f"No instance collection found in empty. Skipping object {blender_object.name}"
-        )
-        return None
+
+    if blender_object.instance_collection and blender_object.instance_type == "COLLECTION":
+        # Empty -> Block
+        return block_instance_to_speckle(blender_object)
+    else:
+        # Empty -> Point
+        wrapper = Base()
+        wrapper["@displayValue"] = matrix_to_speckle_point(cast(MMatrix, blender_object.matrix_world))
+        return wrapper
+
+
+def matrix_to_speckle_point(matrix: MMatrix, units_scale: float = 1.0) -> Point:
+    transformed_pos = cast(MVector, matrix @ MVector((0,0,0)) * units_scale)
+    return Point(x = transformed_pos.x,
+                 y = transformed_pos.y, 
+                 z = transformed_pos.z)
@@ -1,12 +1,21 @@
-import base64
-from typing import Tuple
-import bpy, struct, idprop
+import math
+from typing import Any, Dict, Optional, Tuple, Union, cast
+from bmesh.types import BMesh
+import bpy, idprop

-from specklepy.serialization.base_object_serializer import BaseObjectSerializer
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Mesh
+from specklepy.objects.other import RenderMaterial
+from bpy_speckle.convert.constants import IGNORED_PROPERTY_KEYS
 from bpy_speckle.functions import _report
+from bpy.types import Material, Object, Collection as BCollection, Node, ShaderNodeVertexColor

+from specklepy.objects.graph_traversal.traversal import TraversalContext

-def to_rgba(argb_int: int) -> Tuple[float]:
+class ConversionSkippedException(Exception):
+    pass
+
+def to_rgba(argb_int: int) -> Tuple[float, float, float, float]:
    """Converts the int representation of a colour into a percent RGBA tuple"""
    alpha = ((argb_int >> 24) & 255) / 255
    red = ((argb_int >> 16) & 255) / 255
@@ -16,51 +25,61 @@ def to_rgba(argb_int: int) -> Tuple[float]:
    return (red, green, blue, alpha)


-def to_argb_int(diffuse_colour) -> int:
+def to_argb_int(rgba_color: list[float]) -> int:
    """Converts an RGBA array to an ARGB integer"""
-    diffuse_colour = diffuse_colour[-1:] + diffuse_colour[:3]
-    diffuse_colour = [int(val * 255) for val in diffuse_colour]
+    argb_color = rgba_color[-1:] + rgba_color[:3]
+    int_color = [int(val * 255) for val in argb_color]

-    return int.from_bytes(diffuse_colour, byteorder="big", signed=True)
+    return int.from_bytes(int_color, byteorder="big", signed=True)

+def set_custom_property(key: str, value: Any, blender_object: Object) -> None:
+    try:
+        #Expected c types: float, int, string, float[], int[]
+        blender_object[key] = value
+    except (OverflowError, TypeError) as ex:
+        print(f"Skipping setting property ({key}={value}) on {blender_object.name_full}, Reason: {ex}")
+    except Exception as ex:
+        #TODO: Log this as it's unexpected!!!
+        print(f"Skipping setting property ({key}={value}) on {blender_object.name_full}, Reason: {ex}")

-def add_custom_properties(speckle_object, blender_object):
+def add_custom_properties(speckle_object: Base, blender_object: Object):
    if blender_object is None:
        return

-    serializer = BaseObjectSerializer()
    blender_object["_speckle_type"] = type(speckle_object).__name__

    app_id = getattr(speckle_object, "applicationId", None)
    if app_id:
        blender_object["applicationId"] = speckle_object.applicationId
+    keys = speckle_object.get_dynamic_member_names() if "Geometry" in speckle_object.speckle_type else (set(speckle_object.get_member_names()) - IGNORED_PROPERTY_KEYS)
+    for key in keys:
+        val = getattr(speckle_object, key, None)
+        if val is None:
+            continue

-    for key in speckle_object.get_dynamic_member_names():
-        if isinstance(speckle_object[key], (int, str, float)):
-            blender_object[key] = speckle_object[key]
-        elif isinstance(speckle_object[key], (dict, list)):
-            blender_object[key] = serializer.traverse_value(speckle_object[key])
+        if isinstance(val, (int, str, float)):
+            set_custom_property(key, val, blender_object)
+        elif key == "properties" and isinstance(val, Base):
+            val["applicationId"] = None
+            add_custom_properties(val, blender_object)
+        elif isinstance(val, list):
+            items = [item for item in val if not isinstance(item, Base)]
+            if items:
+                set_custom_property(key, items, blender_object)
+        elif isinstance(val,dict):
+            for (k,v) in val.items():
+                if not isinstance(v, Base):
+                    set_custom_property(k, v, blender_object)


-def add_blender_material(speckle_object, blender_object) -> None:
-    """Add material to a blender object if the corresponding speckle object has a render material"""
-    if blender_object.data is None:
-        return
-
-    speckle_mat = getattr(
-        speckle_object,
-        "renderMaterial",
-        getattr(speckle_object, "@renderMaterial", None),
-    )
-    if not speckle_mat:
-        return
-
-    mat_name = getattr(speckle_mat, "name", None) or speckle_mat.__dict__.get("@name")
+def render_material_to_native(speckle_mat: RenderMaterial) -> Material:
+    
+    mat_name = speckle_mat.name
    if not mat_name:
        mat_name = speckle_mat.applicationId or speckle_mat.id or speckle_mat.get_id()

    blender_mat = bpy.data.materials.get(mat_name)
-    if not blender_mat:
+    if blender_mat is None:
        blender_mat = bpy.data.materials.new(mat_name)

        # for now, we're not updating these materials. as per tom's suggestion, we should have a toggle
@@ -68,19 +87,57 @@ def add_blender_material(speckle_object, blender_object) -> None:
        blender_mat.use_nodes = True
        inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs

-        inputs["Base Color"].default_value = to_rgba(speckle_mat.diffuse)
-        inputs["Emission"].default_value = to_rgba(speckle_mat.emissive)
-        inputs["Roughness"].default_value = speckle_mat.roughness
-        inputs["Metallic"].default_value = speckle_mat.metalness
-        inputs["Alpha"].default_value = speckle_mat.opacity
+        inputs["Base Color"].default_value = to_rgba(speckle_mat.diffuse) # type: ignore
+        inputs["Emission"].default_value = to_rgba(speckle_mat.emissive) # type: ignore
+        inputs["Roughness"].default_value = speckle_mat.roughness # type: ignore
+        inputs["Metallic"].default_value = speckle_mat.metalness # type: ignore
+        inputs["Alpha"].default_value = speckle_mat.opacity # type: ignore

-    if speckle_mat.opacity < 1:
+    if speckle_mat.opacity < 1.0:
        blender_mat.blend_method = "BLEND"

-    blender_object.data.materials.append(blender_mat)
+    return blender_mat
+
+_vertex_color_material: Optional[Material] = None
+
+def get_vertex_color_material() -> Material:
+    global _vertex_color_material
+    
+    #see https://stackoverflow.com/a/69807985
+    if not _vertex_color_material:
+        _vertex_color_material = bpy.data.materials.new("Vertex Color Material")
+        _vertex_color_material.use_nodes = True
+        nodes = _vertex_color_material.node_tree.nodes
+        principled_bsdf_node = cast(Node, nodes.get("Principled BSDF"))
+    
+        if not "VERTEX_COLOR" in [node.type for node in nodes]:
+            vertex_color_node = cast(ShaderNodeVertexColor, nodes.new(type = "ShaderNodeVertexColor"))
+        else:
+            vertex_color_node = cast(ShaderNodeVertexColor, nodes.get("Vertex Color"))
+        vertex_color_node.layer_name = "Col"
+
+        links = _vertex_color_material.node_tree.links
+        link = links.new(vertex_color_node.outputs[0], principled_bsdf_node.inputs[0])
+
+    return _vertex_color_material
+
+def get_render_material(speckle_object: Base) -> Optional[RenderMaterial]:
+    """Trys to get a RenderMaterial on given speckle_object"""
+
+    speckle_mat = getattr(
+        speckle_object,
+        "renderMaterial",
+        getattr(speckle_object, "@renderMaterial", None),
+    )
+
+    if isinstance(speckle_mat, RenderMaterial):
+        return speckle_mat
+
+    return None
+    


-def add_vertices(speckle_mesh, blender_mesh, scale=1.0):
+def add_vertices(speckle_mesh: Mesh, blender_mesh: BMesh, scale=1.0):
    sverts = speckle_mesh.vertices

    if sverts and len(sverts) > 0:
@@ -93,12 +150,11 @@ def add_vertices(speckle_mesh, blender_mesh, scale=1.0):
                )
            )

-    blender_mesh.verts.ensure_lookup_table()


-def add_faces(speckle_mesh, blender_mesh, smooth=False):
+def add_faces(speckle_mesh: Mesh, blender_mesh: BMesh, indexOffset: int, materialIndex: int = 0, smooth:bool = True):
    sfaces = speckle_mesh.faces
-
+    
    if sfaces and len(sfaces) > 0:
        i = 0
        while i < len(sfaces):
@@ -109,18 +165,16 @@ def add_faces(speckle_mesh, blender_mesh, smooth=False):
            i += 1
            try:
                f = blender_mesh.faces.new(
-                    [blender_mesh.verts[int(x)] for x in sfaces[i : i + n]]
+                    [blender_mesh.verts[x + indexOffset] for x in sfaces[i : i + n]] # type: ignore
                )
+                f.material_index = materialIndex
                f.smooth = smooth
            except Exception as e:
                _report(f"Failed to create face for mesh {speckle_mesh.id} \n{e}")
            i += n

-        blender_mesh.faces.ensure_lookup_table()
-        blender_mesh.verts.index_update()

-
-def add_colors(speckle_mesh, blender_mesh):
+def add_colors(speckle_mesh: Mesh, blender_mesh: BMesh):

    scolors = speckle_mesh.colors

@@ -129,10 +183,8 @@ def add_colors(speckle_mesh, blender_mesh):
        if len(scolors) > 0:

            for i in range(len(scolors)):
-                col = int(scolors[i])
-                (a, r, g, b) = [
-                    int(x) for x in struct.unpack("!BBBB", struct.pack("!i", col))
-                ]
+                argb = int(scolors[i])
+                (a, r, g, b) = argb_split(argb)
                colors.append(
                    (
                        float(r) / 255.0,
@@ -143,118 +195,114 @@ def add_colors(speckle_mesh, blender_mesh):
                )

        # Make vertex colors
-        if len(scolors) == len(blender_mesh.verts):
+        if len(scolors) == len(blender_mesh.verts): # type: ignore
            color_layer = blender_mesh.loops.layers.color.new("Col")

-            for face in blender_mesh.faces:
+            for face in blender_mesh.faces: # type: ignore
                for loop in face.loops:
                    loop[color_layer] = colors[loop.vert.index]

+def argb_split(argb: int) -> Tuple[int, int, int, int]:
+    alpha = (argb >> 24) & 0xFF
+    red = (argb >> 16) & 0xFF
+    green = (argb >> 8) & 0xFF
+    blue = argb & 0xFF

-def add_uv_coords(speckle_mesh, blender_mesh):
-    if not hasattr(speckle_mesh, "properties"):
+    return (alpha, red, green, blue)
+
+def add_uv_coords(speckle_mesh: Mesh, blender_mesh: BMesh):
+    s_uvs = speckle_mesh.textureCoordinates
+    if not s_uvs:
        return
+    try:
+        uv = []

-    sprops = speckle_mesh.properties
-    if sprops:
-        texKey = ""
-        if "texture_coordinates" in sprops.keys():
-            texKey = "texture_coordinates"
-        elif "TextureCoordinates" in sprops.keys():
-            texKey = "TextureCoordinates"
+        if len(s_uvs) // 2 == len(blender_mesh.verts): # type: ignore
+            uv.extend(
+                (float(s_uvs[i]), float(s_uvs[i + 1]))
+                for i in range(0, len(s_uvs), 2)
+            )
+        else:
+            _report(
+                f"Failed to match UV coordinates to vert data. Blender mesh verts: {len(blender_mesh.verts)}, Speckle UVs: {len(s_uvs) // 2}" # type: ignore
+            )
+            return

-        if texKey != "":
+        # Make UVs
+        uv_layer = blender_mesh.loops.layers.uv.verify()

-            try:
-                decoded = base64.b64decode(sprops[texKey]).decode("utf-8")
-                s_uvs = decoded.split()
-                uv = []
-
-                if len(s_uvs) // 2 == len(blender_mesh.verts):
-                    for i in range(0, len(s_uvs), 2):
-                        uv.append((float(s_uvs[i]), float(s_uvs[i + 1])))
-                else:
-                    _report(
-                        f"Failed to match UV coordinates to vert data. Blender mesh verts: {len(blender_mesh.verts)}, Speckle UVs * 2: {len(s_uvs) * 2}"
-                    )
-
-                # Make UVs
-                uv_layer = blender_mesh.loops.layers.uv.verify()
-
-                for f in blender_mesh.faces:
-                    for l in f.loops:
-                        luv = l[uv_layer]
-                        luv.uv = uv[l.vert.index]
-            except:
-                _report("Failed to decode texture coordinates.")
-                raise
-
-            del speckle_mesh.properties[texKey]
+        for f in blender_mesh.faces: # type: ignore
+            for l in f.loops:
+                luv = l[uv_layer]
+                luv.uv = uv[l.vert.index]
+    except:
+        _report("Failed to decode texture coordinates.")
+        raise


-ignored_keys = (
+ignored_keys = {
+    "id",
    "speckle",
+    "speckle_type"
    "_speckle_type",
    "_speckle_name",
    "_speckle_transform",
    "_RNA_UI",
+    "elements",
    "transform",
    "_units",
    "_chunkable",
-)
+}

-
-def get_blender_custom_properties(obj, max_depth=1000):
-    if max_depth < 0:
+def get_blender_custom_properties(obj, max_depth: int = 63):
+    """Recursively grabs custom properties on blender objects. Max depth is determined by the max allowed by Newtonsoft.NET, don't exceed unless you know what you're doing"""
+    if max_depth <= 0:
        return obj

    if hasattr(obj, "keys"):
+        keys = set(obj.keys()) - ignored_keys
        return {
            key: get_blender_custom_properties(obj[key], max_depth - 1)
-            for key in obj.keys()
-            if key not in ignored_keys and not key.startswith("_")
+            for key in keys
+            if not key.startswith("_")
        }

-    elif isinstance(obj, (list, tuple, idprop.types.IDPropertyArray)):
-        return [get_blender_custom_properties(o, max_depth - 1) for o in obj]
-    else:
-        return obj
-
+    if isinstance(obj, (list, tuple, idprop.types.IDPropertyArray)):
+        return [get_blender_custom_properties(o, max_depth - 1) for o in obj] # type: ignore
+    
+    return obj

 """
 Python implementation of Blender's NURBS curve generation for to Speckle conversion
 from: https://blender.stackexchange.com/a/34276
+based on https://projects.blender.org/blender/blender/src/branch/main/source/blender/blenkernel/intern/curve.cc (check old version)
 """

-
-def macro_knotsu(nu):
+def macro_knotsu(nu: bpy.types.Spline) -> int:
    return nu.order_u + nu.point_count_u + (nu.order_u - 1 if nu.use_cyclic_u else 0)

-
-def macro_segmentsu(nu):
+def macro_segmentsu(nu: bpy.types.Spline) -> int:
    return nu.point_count_u if nu.use_cyclic_u else nu.point_count_u - 1

-
-def make_knots(nu):
-    knots = [0.0] * (4 + macro_knotsu(nu))
+def make_knots(nu: bpy.types.Spline) -> list[float]:
+    knots = [0.0] * macro_knotsu(nu)
    flag = nu.use_endpoint_u + (nu.use_bezier_u << 1)
    if nu.use_cyclic_u:
        calc_knots(knots, nu.point_count_u, nu.order_u, 0)
-        makecyclicknots(knots, nu.point_count_u, nu.order_u)
    else:
        calc_knots(knots, nu.point_count_u, nu.order_u, flag)
    return knots


-def calc_knots(knots, point_count, order, flag):
+def calc_knots(knots: list[float], point_count: int, order: int, flag: int) -> None:
    pts_order = point_count + order
-    if flag == 1:
+    if flag == 1: # CU_NURB_ENDPOINT
        k = 0.0
        for a in range(1, pts_order + 1):
            knots[a - 1] = k
            if a >= order and a <= point_count:
                k += 1.0
-    elif flag == 2:
+    elif flag == 2: # CU_NURB_BEZIER
        if order == 4:
            k = 0.34
            for a in range(pts_order):
@@ -267,24 +315,176 @@ def calc_knots(knots, point_count, order, flag):
                    k += 0.5
                    knots[a] = math.floor(k)
    else:
-        for a in range(pts_order):
-            knots[a] = a
+        for a in range(1, len(knots) - 1):
+            knots[a] = a - 1

+        knots[-1] = knots[-2]

-def makecyclicknots(knots, point_count, order):
-    order2 = order - 1
+def basis_nurb(t: float, order: int, point_count: int, knots: list[float], basis: list[float], start: int, end: int) -> Tuple[int, int]:
+    i1 = i2 = 0
+    orderpluspnts = order + point_count
+    opp2 = orderpluspnts - 1
+    
+    # this is for float inaccuracy
+    if t < knots[0]:
+        t = knots[0]
+    elif t > knots[opp2]:
+        t = knots[opp2]

-    if order > 2:
-        b = point_count + order2
-        for a in range(1, order2):
-            if knots[b] != knots[b - a]:
+    # this part is order '1'
+    o2 = order + 1
+    for i in range(opp2):
+        if knots[i] != knots[i + 1] and t >= knots[i] and t <= knots[i + 1]:
+            basis[i] = 1.0
+            i1 = i - o2
+            if i1 < 0:
+                i1 = 0
+            i2 = i
+            i += 1
+            while i < opp2:
+                basis[i] = 0.0
+                i += 1
+            break
+
+        else:
+            basis[i] = 0.0
+
+    basis[i] = 0.0 #type: ignore
+
+    # this is order 2, 3, ...
+    for j in range(2, order + 1):
+
+        if i2 + j >= orderpluspnts:
+            i2 = opp2 - j
+
+        for i in range(i1, i2 + 1):
+            if basis[i] != 0.0:
+                d = ((t - knots[i]) * basis[i]) / (knots[i + j - 1] - knots[i])
+            else:
+                d = 0.0
+
+            if basis[i + 1] != 0.0:
+                e = ((knots[i + j] - t) * basis[i + 1]) / (knots[i + j] - knots[i + 1])
+            else:
+                e = 0.0
+
+            basis[i] = d + e
+
+    start = 1000
+    end = 0
+
+    for i in range(i1, i2 + 1):
+        if basis[i] > 0.0:
+            end = i
+            if start == 1000:
+                start = i
+
+    return start, end
+
+def nurb_make_curve(nu: bpy.types.Spline, resolu: int, stride: int = 3) -> list[float]:
+    """"BKE_nurb_makeCurve"""
+    EPS = 1e-6
+    coord_index = istart = iend = 0
+
+    coord_array = [0.0] * (3 * nu.resolution_u * macro_segmentsu(nu))
+    sum_array = [0] * nu.point_count_u
+    basisu = [0.0] * macro_knotsu(nu)
+    knots = make_knots(nu)
+
+    resolu = resolu * macro_segmentsu(nu)
+    ustart = knots[nu.order_u - 1]
+    uend   = knots[nu.point_count_u + nu.order_u - 1] if nu.use_cyclic_u else \
+             knots[nu.point_count_u]
+    ustep  = (uend - ustart) / (resolu - (0 if nu.use_cyclic_u else 1))
+    cycl = nu.order_u - 1 if nu.use_cyclic_u else 0
+
+    u = ustart
+    while resolu:
+        resolu -= 1
+        istart, iend = basis_nurb(u, nu.order_u, nu.point_count_u + cycl, knots, basisu, istart, iend)
+
+        #/* calc sum */
+        sumdiv = 0.0
+        sum_index = 0
+        pt_index = istart - 1
+        for i in range(istart, iend + 1):
+            if i >= nu.point_count_u:
+                pt_index = i - nu.point_count_u
+            else:
+                pt_index += 1
+
+            sum_array[sum_index] = basisu[i] * nu.points[pt_index].co[3] #type: ignore
+            sumdiv += sum_array[sum_index]
+            sum_index += 1
+
+        if (sumdiv != 0.0) and (sumdiv < 1.0 - EPS or sumdiv > 1.0 + EPS):
+            sum_index = 0
+            for i in range(istart, iend + 1):
+                sum_array[sum_index] /= sumdiv #type: ignore
+                sum_index += 1
+
+        coord_array[coord_index: coord_index + 3] = (0.0, 0.0, 0.0)
+
+        sum_index = 0
+        pt_index = istart - 1
+        for i in range(istart, iend + 1):
+            if i >= nu.point_count_u:
+                pt_index = i - nu.point_count_u
+            else:
+                pt_index += 1
+
+            if sum_array[sum_index] != 0.0:
+                for j in range(3):
+                    coord_array[coord_index + j] += sum_array[sum_index] * nu.points[pt_index].co[j]
+            sum_index += 1
+
+        coord_index += stride
+        u += ustep
+
+    return coord_array
+
+def link_object_to_collection_nested(obj: Object, col: BCollection):
+    if obj.name not in col.objects: #type: ignore
+        col.objects.link(obj)
+
+    for child in obj.children: #type: ignore
+        link_object_to_collection_nested(child, col)
+
+def add_to_hierarchy(converted: Union[Object, BCollection], traversalContext : 'TraversalContext', converted_objects: Dict[str, Union[Object, BCollection]], preserve_transform: bool) -> None:
+    nextParent = traversalContext.parent
+
+    # Traverse up the tree to find a direct parent object, and a containing collection
+    parent_collection: Optional[BCollection] = None
+    parent_object: Optional[Object] = None
+
+    while nextParent:
+        if nextParent.current.id in converted_objects:
+            c = converted_objects[nextParent.current.id]
+
+            if isinstance(c, BCollection):
+                parent_collection = c
                break
+            else: #isinstance(c, Object):
+                parent_object = parent_object or c

-            if a == order2:
-                knots[point_count + order - 2] += 1.0
+        nextParent = nextParent.parent

-    b = order
-    c = point_count + order + order2
-    for a in range(point_count + order2, c):
-        knots[a] = knots[a - 1] + (knots[b] - knots[b - 1])
-        b -= 1
+    # If no containing collection is found, fall back to the scene collection
+    if not parent_collection:
+        parent_collection = bpy.context.scene.collection
+
+    if isinstance(converted, Object):
+        if parent_object:
+            set_parent(converted, parent_object, preserve_transform)
+        link_object_to_collection_nested(converted, parent_collection)
+    elif converted.name not in parent_collection.children.keys():
+        parent_collection.children.link(converted)
+
+
+def set_parent(child: Object, parent: Object, preserve_transform: bool = False) -> None:
+    if preserve_transform :
+        previous = child.matrix_world.copy() # type: ignore
+        child.parent = parent
+        child.matrix_world = previous
+    else:
+        child.parent = parent
@@ -1,72 +1,45 @@
-from bpy_speckle.clients import speckle_clients
+from typing import Callable
+from specklepy.objects.base import Base
+from bpy_speckle.convert.constants import ELEMENTS_PROPERTY_ALIASES

-"""
-Speckle functions
-"""
-
-unit_scale = {
-    "meters": 1.0,
-    "centimeters": 0.01,
-    "millimeters": 0.001,
-    "inches": 0.0254,
-    "feet": 0.3048,
-    "kilometers": 1000.0,
-    "mm": 0.001,
-    "cm": 0.01,
-    "m": 1.0,
-    "km": 1000.0,
-    "in": 0.0254,
-    "ft": 0.3048,
-    "yd": 0.9144,
-    "mi": 1609.340,
-}
-
-"""
-Utility functions
-"""
+from specklepy.objects.graph_traversal.traversal import GraphTraversal, TraversalRule
+from specklepy.objects.units import get_scale_factor_to_meters, get_units_from_string


-def _report(msg):
+def _report(msg: object) -> None:
    """
    Function for printing messages to the console
    """
    print("SpeckleBlender: {}".format(msg))


-def get_scale_length(units):
-    if units.lower() in unit_scale.keys():
-        return unit_scale[units]
-    _report("Units <{}> are not supported.".format(units))
-    return 1.0
+def get_scale_length(units: str) -> float:
+    """Returns a scalar to convert distance values from one unit system to meters"""
+    return get_scale_factor_to_meters(get_units_from_string(units))


-"""
-Client, user, and stream functions
-"""
-
-
-def _check_speckle_client_user_stream(scene):
+def get_default_traversal_func(can_convert_to_native: Callable[[Base], bool]) -> GraphTraversal:
    """
-    Verify that there is a valid user and stream
+    Traversal func for traversing a speckle commit object
    """
-    speckle = scene.speckle
-
-    user = (
-        speckle.users[int(speckle.active_user)]
-        if len(speckle.users) > int(speckle.active_user)
-        else None
+    
+    ignore_rule = TraversalRule(
+    [
+        lambda o: "Objects.Structural.Results" in o.speckle_type, #Sadly, this one is necessary to avoid double conversion...
+        lambda o: "Objects.BuiltElements.Revit.Parameter" in o.speckle_type, #This one is just for traversal performance of revit commits
+    ], 
+    lambda _: [],
    )

-    if user is None:
-        print("No users loaded.")
-
-    stream = (
-        user.streams[user.active_stream]
-        if len(user.streams) > user.active_stream
-        else None
+    convertible_rule = TraversalRule(
+    [can_convert_to_native],
+    lambda _: ELEMENTS_PROPERTY_ALIASES,
    )

-    if stream is None:
-        print("Account contains no streams.")

-    return (user, stream)
+    default_rule = TraversalRule(
+    [lambda _: True],
+    lambda o: o.get_member_names(), #TODO: avoid deprecated members
+    )
+
+    return GraphTraversal([ignore_rule, convertible_rule, default_rule])
@@ -1,104 +0,0 @@
-import os, sys, bpy
-import ctypes, sys
-
-import os, sys
-
-
-def modules_path():
-    # set up addons/modules under the user
-    # script path. Here we'll install the
-    # dependencies
-    modulespath = os.path.normpath(
-        os.path.join(bpy.utils.script_path_user(), "addons", "modules")
-    )
-    if not os.path.exists(modulespath):
-        os.makedirs(modulespath)
-
-    # set user modules path at beginning of paths for earlier hit
-    if sys.path[1] != modulespath:
-        sys.path.insert(1, modulespath)
-
-    return modulespath
-
-
-def install_dependencies():
-    import sys
-    import os
-
-    try:
-        try:
-            import pip
-        except:
-            print("Installing pip... "),
-            from subprocess import run as sprun
-
-            res = sprun([bpy.app.binary_path_python, "-m", "ensurepip"])
-
-            if res.returncode == 0:
-                import pip
-            else:
-                raise Exception("Failed to install pip.")
-
-        modulespath = modules_path()
-
-        if not os.path.exists(modulespath):
-            os.makedirs(modulespath)
-
-        print("Installing speckle to {}... ".format(modulespath)),
-        from subprocess import run as sprun
-
-        res = sprun(
-            [
-                bpy.app.binary_path_python,
-                "-m",
-                "pip",
-                "install",
-                "-q",
-                "-t",
-                "{}".format(modulespath),
-                "--no-deps",
-                "pydantic",
-            ]
-        )
-        res = sprun(
-            [
-                bpy.app.binary_path_python,
-                "-m",
-                "pip",
-                "install",
-                "-q",
-                "-t",
-                "{}".format(modulespath),
-                "specklepy",
-            ]
-        )
-
-    except:
-        raise Exception(
-            "Failed to install dependencies. Please make sure you have pip installed."
-        )
-
-
-if __name__ == "__main__":
-    try:
-        import specklepy
-    except:
-        print("Failed to load speckle.")
-        from sys import platform
-
-        if platform == "win32":
-            if ctypes.windll.shell32.IsUserAnAdmin():
-                install_dependencies()
-                import specklepy
-            else:
-                ctypes.windll.shell32.ShellExecuteW(
-                    None, "runas", sys.executable, __file__, None, 1
-                )
-
-        else:
-            print(
-                "Platform {} cannot automatically install dependencies.".format(
-                    platform
-                )
-            )
-            raise
@@ -0,0 +1,207 @@
+"""
+Provides uniform and consistent path helpers for `specklepy`
+"""
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+from importlib import import_module, invalidate_caches
+
+_user_data_env_var = "SPECKLE_USERDATA_PATH"
+
+
+def _path() -> Optional[Path]:
+    """Read the user data path override setting."""
+    path_override = os.environ.get(_user_data_env_var)
+    if path_override:
+        return Path(path_override)
+    return None
+
+
+_application_name = "Speckle"
+
+
+def override_application_name(application_name: str) -> None:
+    """Override the global Speckle application name."""
+    global _application_name
+    _application_name = application_name
+
+
+def override_application_data_path(path: Optional[str]) -> None:
+    """
+    Override the global Speckle application data path.
+
+    If the value of path is `None` the environment variable gets deleted.
+    """
+    if path:
+        os.environ[_user_data_env_var] = path
+    else:
+        os.environ.pop(_user_data_env_var, None)
+
+
+def _ensure_folder_exists(base_path: Path, folder_name: str) -> Path:
+    path = base_path.joinpath(folder_name)
+    path.mkdir(exist_ok=True, parents=True)
+    return path
+
+
+def user_application_data_path() -> Path:
+    """Get the platform specific user configuration folder path"""
+    path_override = _path()
+    if path_override:
+        return path_override
+
+    try:
+        if sys.platform.startswith("win"):
+            app_data_path = os.getenv("APPDATA")
+            if not app_data_path:
+                raise Exception(
+                    "Cannot get appdata path from environment."
+                )
+            return Path(app_data_path)
+        else:
+            # try getting the standard XDG_DATA_HOME value
+            # as that is used as an override
+            app_data_path = os.getenv("XDG_DATA_HOME")
+            if app_data_path:
+                return Path(app_data_path)
+            else:
+                return _ensure_folder_exists(Path.home(), ".config")
+    except Exception as ex:
+        raise Exception(
+            "Failed to initialize user application data path.", ex
+        )
+
+
+def user_speckle_folder_path() -> Path:
+    """Get the folder where the user's Speckle data should be stored."""
+    return _ensure_folder_exists(user_application_data_path(), _application_name)
+
+
+def user_speckle_connector_installation_path(host_application: str) -> Path:
+    """
+    Gets a connector specific installation folder.
+
+    In this folder we can put our connector installation and all python packages.
+    """
+    return _ensure_folder_exists(
+        _ensure_folder_exists(user_speckle_folder_path(), "connector_installations"),
+        host_application,
+    )
+
+
+
+
+
+
+print("Starting module dependency installation")
+print(sys.executable)
+
+PYTHON_PATH = sys.executable
+
+
+
+def connector_installation_path(host_application: str) -> Path:
+    connector_installation_path = user_speckle_connector_installation_path(host_application)
+    connector_installation_path.mkdir(exist_ok=True, parents=True)
+
+    # set user modules path at beginning of paths for earlier hit
+    if sys.path[0] != connector_installation_path:
+        sys.path.insert(0, str(connector_installation_path))
+
+    print(f"Using connector installation path {connector_installation_path}")
+    return connector_installation_path
+
+
+
+def is_pip_available() -> bool:
+    try:
+        import_module("pip")  # noqa F401
+        return True
+    except ImportError:
+        return False
+
+
+def ensure_pip() -> None:
+    print("Installing pip... ")
+
+    from subprocess import run
+
+    completed_process = run([PYTHON_PATH, "-m", "ensurepip"])
+
+    if completed_process.returncode == 0:
+        print("Successfully installed pip")
+    else:
+        raise Exception(f"Failed to install pip, got {completed_process.returncode} return code")
+
+
+def get_requirements_path() -> Path:
+    # we assume that a requirements.txt exists next to the __init__.py file
+    path = Path(Path(__file__).parent, "requirements.txt")
+    assert path.exists()
+    return path
+
+
+def install_requirements(host_application: str) -> None:
+    # set up addons/modules under the user
+    # script path. Here we'll install the
+    # dependencies
+    path = connector_installation_path(host_application)
+    print(f"Installing Speckle dependencies to {path}")
+
+    from subprocess import run
+
+    completed_process = run(
+        [
+            PYTHON_PATH,
+            "-m",
+            "pip",
+            "install",
+            "-t",
+            str(path),
+            "-r",
+            str(get_requirements_path()),
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    if completed_process.returncode != 0:
+        m = f"Failed to install dependenices through pip, got {completed_process.returncode} return code"
+        print(m)
+        raise Exception(m)
+
+
+def install_dependencies(host_application: str) -> None:
+    if not is_pip_available():
+        ensure_pip()
+
+    install_requirements(host_application)
+
+
+def _import_dependencies() -> None:
+    import_module("specklepy")
+    # the code above doesn't work for now, it fails on importing graphql-core
+    # despite that, the connector seams to be working as expected
+    # But it would be nice to make this solution work
+    # it would ensure that all dependencies are fully loaded  
+    # requirements = get_requirements_path().read_text()
+    # reqs = [
+    #     req.split(" ; ")[0].split("==")[0].split("[")[0].replace("-", "_")
+    #     for req in requirements.split("\n")
+    #     if req and not req.startswith(" ")
+    # ]
+    # for req in reqs:
+    #     print(req)
+    #     import_module("specklepy")
+
+def ensure_dependencies(host_application: str) -> None:
+    try:
+        install_dependencies(host_application)
+        invalidate_caches()
+        _import_dependencies()
+        print("Successfully found dependencies")
+    except ImportError:
+        raise Exception(f"Cannot automatically ensure Speckle dependencies. Please try restarting the host application {host_application}!")
+
+
@@ -1,4 +1,4 @@
-from .users import LoadUsers, LoadUserStreams
+from .users import LoadUsers, LoadUserStreams, ResetUsers
 from .object import (
    UpdateObject,
    ResetObject,
@@ -15,7 +15,6 @@ from .streams import (
    SelectOrphanObjects,
 )
 from .streams import (
-    UpdateGlobal,
    AddStreamFromURL,
    CreateStream,
    CopyStreamId,
@@ -27,6 +26,7 @@ from .misc import OpenSpeckleGuide, OpenSpeckleTutorials, OpenSpeckleForum

 operator_classes = [
    LoadUsers,
+    ResetUsers,
    ReceiveStreamObjects,
    SendStreamObjects,
    LoadUserStreams,
@@ -53,7 +53,6 @@ operator_classes.extend(
        ViewStreamDataApi,
        DeleteStream,
        SelectOrphanObjects,
-        UpdateGlobal,
        AddStreamFromURL,
        CreateStream,
        OpenSpeckleGuide,
@@ -3,13 +3,15 @@ Commit operators
 """
 import bpy
 from bpy.props import BoolProperty
-from bpy_speckle.functions import _check_speckle_client_user_stream
 from bpy_speckle.clients import speckle_clients
+from bpy_speckle.properties.scene import get_speckle
+from specklepy.logging import metrics


 class DeleteCommit(bpy.types.Operator):
    """
-    Delete stream
+    Deletes the selected commit from the selected stream.
+    To execute from code, call: `bpy.ops.speckle.delete_commit(are_you_sure=True)`
    """

    bl_idname = "speckle.delete_commit"
@@ -28,36 +30,46 @@ class DeleteCommit(bpy.types.Operator):
        col.prop(self, "are_you_sure")

    def invoke(self, context, event):
+        speckle = get_speckle(context)
        wm = context.window_manager
-        if len(context.scene.speckle.users) > 0:
+        if len(speckle.users) > 0:
            return wm.invoke_props_dialog(self)

        return {"CANCELLED"}

    def execute(self, context):
+        try:
+            self.delete_commit(context)
+            return {"FINISHED"}
+        except Exception as ex:
+            print(f"{self.bl_idname}: failed: {ex}")
+            return {"CANCELLED"}
+
+    def delete_commit(self, context: bpy.types.Context) -> None: 

        if not self.are_you_sure:
-            return {"CANCELLED"}
+            raise Exception("Cancelled by user")

        self.are_you_sure = False

-        speckle = context.scene.speckle
+        speckle = get_speckle(context)

-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
+        (_, stream, _, commit) = speckle.validate_commit_selection()

-        user, stream = check
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        branch = stream.branches[int(stream.branch)]
-        if len(branch.commits) < 1:
-            return {"CANCELLED"}
-        commit = branch.commits[int(branch.commit)]
+        client = speckle_clients[int(speckle.active_user)]

        deleted = client.commit.delete(stream_id=stream.id, commit_id=commit.id)

-        return {"FINISHED"}
+        metrics.track(
+            "Connector Action",
+            client.account, 
+            custom_props={
+                "name": "delete_commit"
+            },
+        )
+        
+        if not deleted:
+            raise Exception("Delete operation failed")
+
+        print(f"{self.bl_idname}: succeeded - commit {commit.id} ({commit.message}) has been deleted from stream {stream.id}")
+
@@ -1,5 +1,6 @@
 import bpy
 import webbrowser
+from specklepy.logging import metrics 


 class OpenSpeckleGuide(bpy.types.Operator):
@@ -10,6 +11,13 @@ class OpenSpeckleGuide(bpy.types.Operator):

    def execute(self, context):
        webbrowser.open("https://speckle.guide/user/blender.html")
+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "OpenSpeckleGuide"
+            },
+        )
        return {"FINISHED"}


@@ -21,6 +29,13 @@ class OpenSpeckleTutorials(bpy.types.Operator):

    def execute(self, context):
        webbrowser.open("https://speckle.systems/tutorials/")
+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "OpenSpeckleTutorials"
+            },
+        )
        return {"FINISHED"}


@@ -32,4 +47,11 @@ class OpenSpeckleForum(bpy.types.Operator):

    def execute(self, context):
        webbrowser.open("https://speckle.community/")
+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "OpenSpeckleForum"
+            },
+        )
        return {"FINISHED"}
@@ -4,13 +4,14 @@ Object operators

 import bpy
 from bpy.props import BoolProperty, EnumProperty
+from deprecated import deprecated
 from bpy_speckle.convert.to_speckle import (
    convert_to_speckle,
    ngons_to_speckle_polylines,
 )
 from bpy_speckle.functions import get_scale_length, _report
 from bpy_speckle.clients import speckle_clients
-
+from specklepy.logging import metrics

 class UpdateObject(bpy.types.Operator):
    """
@@ -28,7 +29,6 @@ class UpdateObject(bpy.types.Operator):
    def execute(self, context):
        user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
        client = speckle_clients[int(context.scene.speckle.active_user)]
-        stream = user.streams[user.active_stream]

        active = context.active_object
        _report(active)
@@ -56,6 +56,13 @@ class UpdateObject(bpy.types.Operator):
                _report("Updating object {}".format(sm["_id"]))
                client.objects.update(active.speckle.object_id, sm)

+                metrics.track(
+                    "Connector Action",
+                    None, 
+                    custom_props={
+                        "name": "UpdateObject"
+                    },
+                )
                return {"FINISHED"}

            return {"CANCELLED"}
@@ -79,6 +86,14 @@ class ResetObject(bpy.types.Operator):
        context.object.speckle.enabled = False
        context.view_layer.update()

+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "ResetObject"
+            },
+        )
+
        return {"FINISHED"}


@@ -125,9 +140,17 @@ class DeleteObject(bpy.types.Operator):
            active.speckle.enabled = False
            context.view_layer.update()

+            metrics.track(
+                "Connector Action",
+                None, 
+                custom_props={
+                    "name": "DeleteObject"
+                },
+            )
+
        return {"FINISHED"}

-
+@deprecated
 class UploadNgonsAsPolylines(bpy.types.Operator):
    """
    Upload mesh ngon faces as polyline outlines
@@ -151,9 +174,10 @@ class UploadNgonsAsPolylines(bpy.types.Operator):
            client = speckle_clients[int(context.scene.speckle.active_user)]
            stream = user.streams[user.active_stream]

-            scale = context.scene.unit_settings.scale_length / get_scale_length(
-                stream.units
-            )
+            # scale = context.scene.unit_settings.scale_length / get_scale_length(
+            #     stream.units
+            # )
+            scale = 1.0

            sp = ngons_to_speckle_polylines(active, scale)

@@ -196,6 +220,13 @@ class UploadNgonsAsPolylines(bpy.types.Operator):
            context.view_layer.update()
            _report("Done.")

+            metrics.track(
+                "Connector Action",
+                None, 
+                custom_props={
+                    "name": "UploadNgonsAsPolylines"
+                },
+            )
        return {"FINISHED"}

    def invoke(self, context, event):
@@ -266,6 +297,14 @@ class SelectIfSameCustomProperty(bpy.types.Operator):
            else:
                obj.select_set(False)

+            metrics.track(
+                "Connector Action",
+                None, 
+                custom_props={
+                    "name": "SelectIfSameCustomProperty"
+                },
+            )
+                
        return {"FINISHED"}


@@ -314,4 +353,13 @@ class SelectIfHasCustomProperty(bpy.types.Operator):
            else:
                obj.select_set(False)

+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "SelectIfHasCustomProperty"
+            },
+        )
+
+
        return {"FINISHED"}
@@ -1,12 +1,48 @@
 """
 User account operators
 """
+from typing import cast
 import bpy
+from bpy.types import Context
 from bpy_speckle.functions import _report
 from bpy_speckle.clients import speckle_clients
-from specklepy.api.client import SpeckleClient
-from specklepy.api.credentials import get_local_accounts
+from bpy_speckle.properties.scene import SpeckleCommitObject, SpeckleSceneSettings, SpeckleStreamObject, SpeckleUserObject, get_speckle
+from specklepy.core.api.client import SpeckleClient
+from specklepy.core.api.models import Stream
+from specklepy.core.api.credentials import get_local_accounts, Account
+from specklepy.logging import metrics

+class ResetUsers(bpy.types.Operator):
+    """
+    Reset loaded users
+    """
+
+    bl_idname = "speckle.users_reset"
+    bl_label = "Reset users"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        self.reset_ui(context)
+
+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "ResetUsers"
+            },
+        )
+
+        bpy.context.view_layer.update()
+        if context.area:
+            context.area.tag_redraw()
+        return {"FINISHED"}
+
+    @staticmethod
+    def reset_ui(context: Context):
+        speckle = get_speckle(context)
+
+        speckle.users.clear()
+        speckle_clients.clear()

 class LoadUsers(bpy.types.Operator):
    """
@@ -21,45 +57,78 @@ class LoadUsers(bpy.types.Operator):

        _report("Loading users...")

-        users = context.scene.speckle.users
+        speckle = cast(SpeckleSceneSettings, context.scene.speckle) #type: ignore
+        users_list = speckle.users

-        context.scene.speckle.users.clear()
-        speckle_clients.clear()
+        ResetUsers.reset_ui(context)

        profiles = get_local_accounts()
+        active_user_index = 0
+
+        metrics.track(
+            "Connector Action",
+            None, 
+            custom_props={
+                "name": "LoadUsers",
+            },
+        )
+
+        if not profiles:
+            raise Exception("Zero accounts were found, please add one through Speckle Manager or a local account")

        for profile in profiles:
-            user = users.add()
-            user.server_name = profile.serverInfo.name or "Speckle Server"
-            user.server_url = profile.serverInfo.url
-            user.name = profile.userInfo.name
-            user.email = profile.userInfo.email
-            user.company = profile.userInfo.company or ""
-            user.authToken = profile.token
            try:
-                client = SpeckleClient(
-                    host=profile.serverInfo.url,
-                    use_ssl="https" in profile.serverInfo.url,
-                )
-                client.authenticate(user.authToken)
-                speckle_clients.append(client)
+                add_user_account(profile, speckle)
            except Exception as ex:
-                _report(ex)
-                users.remove(len(users) - 1)
-            if profile.isDefault:
-                context.scene.speckle.active_user = str(len(users) - 1)
+                _report(f"Failed to authenticate user account {profile.userInfo.email} with server {profile.serverInfo.url}: {ex}")
+                users_list.remove(len(users_list) - 1)
+                continue
+
+            if profile.isDefault:
+                active_user_index = len(users_list) - 1
+
+        _report(f"Authenticated {len(users_list)}/{len(profiles)} accounts")
+
+        if active_user_index < len(users_list):
+            speckle.active_user = str(active_user_index)

-        context.scene.speckle.active_user_index = int(context.scene.speckle.active_user)
-        bpy.ops.speckle.load_user_streams()
        bpy.context.view_layer.update()

        if context.area:
            context.area.tag_redraw()
+
+        if not users_list:
+            raise Exception("Zero valid user accounts were found, please ensure account is valid and the server is running")
+
        return {"FINISHED"}

+def add_user_account(account: Account, speckle: SpeckleSceneSettings) -> SpeckleUserObject:
+    """Creates a new new SpeckleUserObject for the provided user Account and adds it to the SpeckleSceneSettings"""
+    users_list = speckle.users

-def add_user_stream(user, stream):
-    s = user.streams.add()
+    URL = account.serverInfo.url
+
+    user = cast(SpeckleUserObject, users_list.add())
+    user.server_name = account.serverInfo.name or "Speckle Server"
+    user.server_url = URL
+    user.id = account.userInfo.id
+    user.name = account.userInfo.name
+    user.email = account.userInfo.email
+    user.company = account.userInfo.company or ""
+
+    assert(URL)
+    client = SpeckleClient(
+        host=URL,
+        use_ssl="https" in URL,
+    )
+    client.authenticate_with_account(account)
+    speckle_clients.append(client)
+    return user
+
+
+def add_user_stream(user: SpeckleUserObject, stream: Stream):
+    """Adds the provided Stream (with branch & commits) to the SpeckleUserObject"""
+    s = cast(SpeckleStreamObject, user.streams.add())
    s.name = stream.name
    s.id = stream.id
    s.description = stream.description
@@ -76,23 +145,24 @@ def add_user_stream(user, stream):
            continue

        for c in b.commits.items:
-            commit = branch.commits.add()
+            commit: SpeckleCommitObject = branch.commits.add()
            commit.id = commit.name = c.id
            commit.message = c.message or ""
            commit.author_name = c.authorName
            commit.author_id = c.authorId
-            commit.created_at = c.createdAt
+            commit.created_at = c.createdAt.strftime("%Y-%m-%d %H:%M:%S.%f%Z") if c.createdAt else ""
            commit.source_application = str(c.sourceApplication)
+            commit.referenced_object = c.referencedObject

    if hasattr(s, "baseProperties"):
-        s.units = stream.baseProperties.units
+        s.units = stream.baseProperties.units # type: ignore
    else:
        s.units = "Meters"


 class LoadUserStreams(bpy.types.Operator):
    """
-    Load all available streams for active user user
+    Load all available streams for active user
    """

    bl_idname = "speckle.load_user_streams"
@@ -100,34 +170,50 @@ class LoadUserStreams(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "(Re)load all available user streams"

+    stream_limit: int = 20
+    branch_limit: int = 20
+
    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) > 0:
-            user = speckle.users[int(context.scene.speckle.active_user)]
-            client = speckle_clients[int(context.scene.speckle.active_user)]
-
-            try:
-                streams = client.stream.list(stream_limit=20)
-            except Exception as e:
-                _report("Failed to retrieve streams: {}".format(e))
-                return
-            if not streams:
-                _report("Failed to retrieve streams.")
-                return
-
-            user.streams.clear()
-
-            default_units = "Meters"
-
-            for s in streams:
-                sstream = client.stream.get(id=s.id)
-                add_user_stream(user, sstream)
-
-            bpy.context.view_layer.update()
-
+        try:
+            self.load_user_stream(context)
            return {"FINISHED"}
+        except Exception as ex:
+            _report(f"{self.bl_idname} failed: {ex}")
+            return {"CANCELLED"} 
+        
+    def load_user_stream(self, context: Context) -> None:
+        speckle = get_speckle(context)
+
+        user = speckle.validate_user_selection()
+
+        client = speckle_clients[int(speckle.active_user)]
+        try:
+            streams = client.stream.list(stream_limit=self.stream_limit)
+        except Exception as ex:
+            raise Exception(f"Failed to retrieve streams") from ex
+        
+        if not streams:
+            raise Exception("Zero streams found")
+            return
+
+        user.streams.clear()
+
+        for s in streams:
+            assert(s.id)
+            sstream = client.stream.get(id=s.id, branch_limit=self.branch_limit)
+            add_user_stream(user, sstream)
+
+        bpy.context.view_layer.update()

        if context.area:
            context.area.tag_redraw()
-        return {"CANCELLED"}
+                
+        metrics.track(
+            "Connector Action",
+            client.account, 
+            custom_props={
+                "name": "LoadUserStreams"
+            },
+        )
+
+
@@ -1,6 +1,7 @@
 """
 Scene properties
 """
+from typing import Optional, Tuple
 import bpy
 from bpy.props import (
    StringProperty,
@@ -12,18 +13,18 @@ from bpy.props import (
    PointerProperty,
 )

-
 class SpeckleSceneObject(bpy.types.PropertyGroup):
    name: bpy.props.StringProperty(default="")


 class SpeckleCommitObject(bpy.types.PropertyGroup):
-    id: StringProperty(default="abc")
-    message: StringProperty(default="A simple commit")
-    author_name: StringProperty(default="Author name")
-    author_id: StringProperty(default="Author ID")
-    created_at: StringProperty(default="Today")
-    source_application: StringProperty(default="Unknown")
+    id: StringProperty(default="")
+    message: StringProperty(default="")
+    author_name: StringProperty(default="")
+    author_id: StringProperty(default="")
+    created_at: StringProperty(default="")
+    source_application: StringProperty(default="")
+    referenced_object: StringProperty(default="")


 class SpeckleBranchObject(bpy.types.PropertyGroup):
@@ -42,6 +43,12 @@ class SpeckleBranchObject(bpy.types.PropertyGroup):
        description="Active commit",
        items=get_commits,
    )
+    
+    def get_active_commit(self) -> Optional[SpeckleCommitObject]:
+        selected_index = int(self.commit)
+        if 0 <= selected_index < len(self.commits): 
+            return self.commits[selected_index]
+        return None


 class SpeckleStreamObject(bpy.types.PropertyGroup):
@@ -66,17 +73,28 @@ class SpeckleStreamObject(bpy.types.PropertyGroup):
        items=get_branches,
    )

+    def get_active_branch(self) -> Optional[SpeckleBranchObject]:
+        selected_index = int(self.branch)
+        if 0 <= selected_index < len(self.branches): 
+            return self.branches[selected_index]
+        return None
+

 class SpeckleUserObject(bpy.types.PropertyGroup):
    server_name: StringProperty(default="SpeckleXYZ")
    server_url: StringProperty(default="https://speckle.xyz")
+    id: StringProperty(default="")
    name: StringProperty(default="Speckle User")
    email: StringProperty(default="user@speckle.xyz")
    company: StringProperty(default="SpeckleSystems")
-    authToken: StringProperty(default="")
    streams: CollectionProperty(type=SpeckleStreamObject)
    active_stream: IntProperty(default=0)

+    def get_active_stream(self) -> Optional[SpeckleStreamObject]:
+        selected_index = int(self.active_stream)
+        if 0 <= selected_index < len(self.streams): 
+            return self.streams[selected_index]
+        return None

 class SpeckleSceneSettings(bpy.types.PropertyGroup):
    def get_scripts(self, context):
@@ -104,8 +122,8 @@ class SpeckleSceneSettings(bpy.types.PropertyGroup):

    active_user: EnumProperty(
        items=get_users,
-        name="User",
-        description="Select user",
+        name="Account",
+        description="Select account",
        update=set_user,
        get=None,
        set=None,
@@ -132,3 +150,47 @@ class SpeckleSceneSettings(bpy.types.PropertyGroup):
        description="Script to run when sending stream objects.",
        items=get_scripts,
    )
+
+    def get_active_user(self) -> Optional[SpeckleUserObject]:
+        selected_index = int(self.active_user)
+        if 0 <= selected_index < len(self.users):
+            return self.users[selected_index]
+        return None
+    
+
+    def validate_user_selection(self) -> SpeckleUserObject:
+        user = self.get_active_user()
+        if not user:
+            raise SelectionException("No user selected/found")
+        return user
+        
+    def validate_stream_selection(self) -> Tuple[SpeckleUserObject, SpeckleStreamObject]:
+        user = self.validate_user_selection()
+
+        stream = user.get_active_stream()
+        if not stream:
+            raise SelectionException("No stream selected/found")
+
+        return (user, stream)
+    
+    def validate_branch_selection(self) -> Tuple[SpeckleUserObject, SpeckleStreamObject, SpeckleBranchObject]:
+        (user, stream) = self.validate_stream_selection()
+
+        branch = stream.get_active_branch()
+        if not branch:
+            raise SelectionException("No branch selected/found")
+        return (user, stream, branch)
+    
+    def validate_commit_selection(self) ->Tuple[SpeckleUserObject, SpeckleStreamObject, SpeckleBranchObject, SpeckleCommitObject]:
+        (user, stream, branch) = self.validate_branch_selection()
+        commit = branch.get_active_commit()
+        if commit is None:
+            raise SelectionException("No commit selected/found")
+        
+        return (user, stream, branch, commit)
+    
+class SelectionException(Exception):
+    pass
+
+def get_speckle(context: bpy.types.Context) -> SpeckleSceneSettings:
+    return context.scene.speckle #type: ignore
@@ -12,7 +12,7 @@ from bpy.props import (
    EnumProperty,
 )

-import datetime
+from datetime import datetime

 """
 Compatibility 
@@ -115,13 +115,14 @@ class VIEW3D_PT_SpeckleUser(bpy.types.Panel):
        col = layout.column()

        if len(speckle.users) < 1:
-            col.label(text="No users found.")
+            col.label(text="Refresh to initialise")
        else:
            col.prop(speckle, "active_user", text="")
            user = speckle.users[int(speckle.active_user)]
            col.label(text="{} ({})".format(user.server_name, user.server_url))
            col.label(text="{} ({})".format(user.name, user.email))
-
+            
+        col.operator("speckle.users_load", text="", icon="FILE_REFRESH")

 class VIEW3D_PT_SpeckleStreams(bpy.types.Panel):
    """
@@ -177,7 +178,7 @@ class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):
                stream = user.streams[user.active_stream]
                # user.active_stream = min(user.active_stream, len(user.streams) - 1)
                row = col.row()
-                row.label(text="{} ({})".format(stream.name, stream.id))
+                row.label(text=f"{stream.name} ({stream.id})")
                row.operator("speckle.stream_copy_id", text="", icon="COPY_ID")
                col.separator()

@@ -205,13 +206,11 @@ class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):
                            row.label(text=line)
                        area.separator()

-                        dt = datetime.datetime.strptime(
-                            commit.created_at, "%Y-%m-%dT%H:%M:%S.%fZ"
-                        )
-                        col.label(text="{}".format(dt.ctime()))
-                        col.label(
-                            text="{} ({})".format(commit.author_name, commit.author_id)
+                        dt = datetime.strptime(
+                            commit.created_at, "%Y-%m-%d %H:%M:%S.%f%Z"
                        )
+                        col.label(text=f"{dt.ctime()}")
+                        col.label(text=f"{commit.author_name} ({commit.author_id})")
                        col.label(text=commit.source_application)
                else:
                    col.label(text="No branches found!")
@@ -232,9 +231,6 @@ class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):

                row = col.row(align=True)
                subcol = row.column()
-                subcol.label(text="Units:")
-                subcol = row.column()
-                subcol.label(text=stream.units)

                col.label(text="Description:")
                area = col.box()
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -e -o pipefail
+
+poetry export --only main -o bpy_speckle/requirements.txt
@@ -0,0 +1,20 @@
+import sys
+from pathlib import Path
+
+
+def patch_installer(tag: str):
+    """Patches the installer with the correct connector version and specklepy version"""
+    tag = tag.replace("\n", "")
+    iss_file = "speckle-sharp-ci-tools/blender.iss"
+    iss_path =  Path(iss_file)
+    lines = iss_path.read_text().split("\n")
+    lines.insert(12, f'#define AppVersion "{tag.split("-")[0]}"')
+    lines.insert(13, f'#define AppInfoVersion "{tag}"')
+
+    iss_path.write_text("\n".join(lines))
+    print(f"Patched installer with connector v{tag}")
+
+
+if __name__ == "__main__":
+    tag = sys.argv[1]
+    patch_installer(tag)
@@ -1,7 +1,6 @@
 import re
 import sys

-
 def patch_connector(tag):
    """Patches the connector version within the connector init file"""
    bpy_file = "bpy_speckle/__init__.py"
@@ -19,47 +18,13 @@ def patch_connector(tag):
        with open(bpy_file, "w") as file:
            file.writelines(lines)

-
-def patch_installer(tag):
-    """Patches the installer with the correct connector version and specklepy version"""
-    iss_file = "speckle-sharp-ci-tools/blender.iss"
-
-    py_tag = get_specklepy_version()
-    with open(iss_file, "r") as file:
-        lines = file.readlines()
-        lines.insert(11, f'#define SpecklepyVersion "{py_tag}"\n')
-        lines.insert(11, f'#define AppVersion "{tag}"\n')
-
-        with open(iss_file, "w") as file:
-            file.writelines(lines)
-            print(f"Patched installer with connector v{tag} and specklepy v{py_tag}")
-
-
-def get_specklepy_version():
-    """Get version of specklepy to install from the pyproject.toml"""
-    version = "2.3.3"
-    with open("pyproject.toml", "r") as f:
-        lines = [line for line in f if line.startswith("specklepy = ")]
-        if not lines:
-            raise Exception("Could not find specklepy in pyproject.toml")
-        match = re.search(r"[0-9]+(\.[0-9]+)*", lines[0])
-        if match:
-            version = match[0]
-    return version
-
-
 def main():
-    if len(sys.argv) < 2:
-        print(get_specklepy_version())
-        return
-
    tag = sys.argv[1]
-    if not re.match(r"[0-9]+(\.[0-9]+)*$", tag):
+    if not re.match(r"([0-9]+)\.([0-9]+)\.([0-9]+)", tag):
        raise ValueError(f"Invalid tag provided: {tag}")

    print(f"Patching version: {tag}")
-    patch_connector(tag)
-    patch_installer(tag)
+    patch_connector(tag.split("-")[0])


 if __name__ == "__main__":
@@ -2,20 +2,22 @@
 name = "speckle-blender"
 version = "2.0.0"
 description = "the Speckle 2.0 connector for Blender!"
-authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>"]
+authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>", "Gergő Jedlicska <gergo@jedlicska.com>"]
 license = "Apache-2.0"

 [tool.poetry.dependencies]
-python = ">=3.7,<3.10"
-specklepy = "^2.6.0"
+python = ">=3.8, <4.0.0"
+specklepy = "^2.16.2"
+attrs = "^23.1.0"

-[tool.poetry.dev-dependencies]
-devtools = "^0.6.1"
-numpy = "^1.20.2"
-bpy = "^2.82.1"
-bpy-build = "^2.1.0"
-black = "^21.12b0"
-pylint = "^2.12.2"
+# [tool.poetry.group.local_specklepy.dependencies]
+# specklepy = {path = "../specklepy", develop = true}
+
+[tool.poetry.group.dev.dependencies]
+fake-bpy-module-latest = "^20230117"
+black = "^22.10.0"
+pylint = "^2.15.7"
+ruff = "^0.0.187"

 [build-system]
 requires = ["poetry-core>=1.0.0"]
Author	SHA1	Message	Date
Jedd Morgan	dabb65427a	Added defaults to converter settings so converter can be used without connector	2023-10-18 15:48:31 +01:00
Jedd Morgan	57ece17e8b	Merge pull request #177 from specklesystems/jrm/chore/comments chore: fixed some mistakes in code comments	2023-10-16 11:43:58 +01:00
Jedd Morgan	4362f737d0	chore: fixed some mistakes in code comments	2023-10-16 11:43:36 +01:00
Jedd Morgan	b55df58313	Merge pull request #176 from specklesystems/jrm/blender/automate Extracted some functions for automate	2023-10-13 13:02:28 +01:00
Jedd Morgan	afa6722253	Extracted some functions for automate	2023-10-13 12:56:30 +01:00
Jedd Morgan	a3d4881578	Merge pull request #175 from specklesystems/jrm/properties/depth fix(custom_properties): Set max depth of properties to 64 to align with newtonsoft limit	2023-10-08 18:45:50 +01:00
JR-Morgan	1af158a5e0	poetry lock	2023-10-08 18:44:18 +01:00
JR-Morgan	47857a9db0	Aligned json depth cap with newtonsofts reader at 64 levels of depth	2023-10-08 18:40:43 +01:00
Jedd Morgan	3b026e6027	Merge pull request #173 from specklesystems/jrm/fix-py-indent-error Update users.py	2023-09-22 13:03:32 +01:00
Jedd Morgan	d572609f75	Update users.py	2023-09-22 13:03:06 +01:00
Jedd Morgan	37032cc7aa	Merge pull request #172 from specklesystems/jrm/deps/specklepy216 better error message when user has no valid accounts	2023-09-12 12:35:03 +01:00
Jedd Morgan	6027325878	better error message when user has no valid accounts	2023-09-12 11:59:39 +01:00
Jedd Morgan	5ddb2aa052	Merge pull request #171 from specklesystems/jrm/deps/specklepy216 fix(receive)!: Fixed issue with collection name conflicts	2023-09-12 10:50:15 +01:00
Jedd Morgan	67a18821cc	fix(receive)!: Collections will no longer update	2023-09-12 10:36:22 +01:00
Jedd Morgan	2688a69286	Merge pull request #169 from specklesystems/jrm/deps/specklepy216 Jrm/deps/specklepy216	2023-09-08 16:04:08 +01:00
Jedd Morgan	56216a6137	bump specklepy	2023-09-08 15:39:25 +01:00
Jedd Morgan	319cbf8960	Specklepy 2.16	2023-09-08 13:41:14 +01:00
Jedd Morgan	d7ac6c0b95	Updated to new core metrics	2023-09-04 19:51:39 +01:00
Jedd Morgan	201ca5f26e	Update blender_commit_object_builder.py	2023-07-22 01:02:23 +01:00
Jedd Morgan	89528437b1	Merge pull request #167 from specklesystems/vertex-color-uint Fixed issue with uint32 vertex colours not parsing	2023-07-17 21:51:18 +01:00
Jedd Morgan	91bde24fe9	Fixed issue with uint32 vertex colors not parsing	2023-07-17 21:21:28 +01:00
Jedd Morgan	991b0f9ff1	Merge pull request #166 from specklesystems/2.15-deps-update Fixed issue with hosted elements on nested instances not receiving or receiving twice	2023-07-06 15:20:58 +01:00
Jedd Morgan	ee1715ff8a	fixed circular import	2023-07-06 15:12:34 +01:00
Jedd Morgan	70ee09b9bb	Fixed issue with non-convertable revit definitions	2023-07-06 13:57:44 +01:00
Jedd Morgan	83dd62d03f	deps update	2023-07-06 13:16:50 +01:00
Jedd Morgan	94cc0ac3f7	fix(instance): Fixed issues with hosted and nested instances	2023-07-06 13:14:20 +01:00
Jedd Morgan	36cb94d3d7	fix(converter): ToSpeckle instances	2023-07-03 16:59:53 +01:00
Jedd Morgan	c60baf78c5	deps: updated to specklepy 2.15.0	2023-06-27 16:09:04 +01:00
Jedd Morgan	d72cfd3522	feat(view): Added support for receiving/sending view objects	2023-05-31 01:12:17 +01:00
Jedd Morgan	a26618a4f7	Merge pull request #164 from specklesystems/2.14/bug-fixes 2.14/bug fixes	2023-05-29 13:39:06 +01:00
Jedd Morgan	eaf370407d	Updated lock	2023-05-29 13:37:49 +01:00
Jedd Morgan	a2b50fe5a1	Added support for sending diffuse BSDF shader materials	2023-05-29 13:33:53 +01:00
Jedd Morgan	7e62f76841	fix: fixed bug with imperial units scaling on send	2023-05-29 12:40:54 +01:00
Jedd Morgan	fc804f16d3	Fixed bug with circular referenced custom props	2023-05-29 12:40:34 +01:00
Jedd Morgan	6c7da24595	Merge pull request #163 from specklesystems/collections Collections	2023-05-27 13:44:19 +01:00
Jedd Morgan	b284d39328	removed normal re-calculation	2023-05-27 13:43:42 +01:00
Jedd Morgan	907185c9bb	Object naming tweaks	2023-05-26 18:58:42 +01:00
Jedd Morgan	a189a2e1c0	Various cleanup and bug fixes	2023-05-26 18:18:10 +01:00
Jedd Morgan	1fad926275	Remove empty collections from send	2023-05-25 21:01:34 +01:00
Jedd Morgan	99c147fe2f	Sending collections (all collections regardless of contents)	2023-05-25 17:45:31 +01:00
Jedd Morgan	e2adf710b3	commit object builder	2023-05-25 00:22:09 +01:00
Jedd Morgan	9509344533	Added traversal refactor and support for receiving collections	2023-05-18 22:15:35 +01:00
Jedd Morgan	6fabc6cae6	feat(converter): implemented view to native	2023-05-10 17:31:18 +01:00
Jedd Morgan	c39298687d	Merge pull request #160 from specklesystems/jrm/ismultiplayer Added `isMultiplayer` property	2023-04-13 14:26:29 +01:00
Jedd Morgan	bcdddbf930	Added `isMultiplayer` property	2023-04-13 14:24:17 +01:00
Jedd Morgan	b5684e34f6	Merge pull request #159 from specklesystems/jrm/curve-fix Removed merge vertices by distance from clean mesh	2023-04-05 12:51:27 +01:00
Jedd Morgan	2203fe98f8	Removed merge vertices by distance from clean mesh	2023-04-05 12:47:03 +01:00
Jedd Morgan	bbfdf2863b	Merge pull request #158 from specklesystems/jrm/curve-fix Using new installer.py	2023-04-04 20:22:48 +01:00
Jedd Morgan	f25f6cb16c	Fixed some misc issues	2023-04-04 20:21:20 +01:00
Jedd Morgan	9e4e533ba8	Using new installer.py	2023-03-28 17:06:40 +01:00
Jedd Morgan	8db12ca9b9	Merge pull request #157 from specklesystems/jrm/curve-fix Mesh area calc + minor cleanup	2023-03-28 16:47:59 +01:00
Jedd Morgan	366c864247	Mesh area calc + minor cleanup	2023-03-28 16:47:07 +01:00
Jedd Morgan	52136d3ef6	Merge pull request #155 from specklesystems/jrm/instances Implemented support for new instances	2023-03-21 22:01:46 +00:00
Jedd Morgan	fe764d7f0c	removed old comment	2023-03-21 21:58:07 +00:00
Jedd Morgan	669dd67521	Added option to receive instances as linked duplicates	2023-03-21 21:45:53 +00:00
Jedd Morgan	f74b2c37f0	Implemented support for new instances	2023-03-19 03:08:57 +00:00
Jedd Morgan	ebb4e32fff	Merge pull request #151 from specklesystems/jrm/curve-fix Fixes many bugs with curves	2023-03-09 14:52:28 +00:00
Jedd Morgan	25903baf83	Set default mesh smoothing to True	2023-02-21 19:19:31 +00:00
Jedd Morgan	cb6d6d7ad8	feat(converter): Added support for Ellipse and Circles	2023-02-21 19:17:14 +00:00
Jedd Morgan	fd2687aa3c	All non-bezier nurbs curves now work perfectly rhino->blend->rhino	2023-02-20 22:26:11 +00:00
Jedd Morgan	f5c65068de	feat(converter): Better curve support	2023-02-18 02:23:41 +00:00
Jedd Morgan	235b49d8c6	Merge pull request #150 from specklesystems/hotfix-authtoken fix(auth): hotfix for serializing authTokens in blender file	2023-02-15 18:00:53 +00:00
Jedd Morgan	a1ec137c67	minor cleanup	2023-02-15 16:40:49 +00:00
Jedd Morgan	b95f621272	Aligned nurbs knot multiplicities with rhino curves	2023-02-15 16:37:48 +00:00
Jedd Morgan	a1fcdad0e3	fix(auth): hotfix for serializing authTokens in blender file	2023-02-15 15:41:36 +00:00
Gergő Jedlicska	584e543964	makes sure to insert a path string into the sys path not a path object (#149 )	2023-02-08 12:45:29 +01:00
Jedd Morgan	ef20c5240c	Merge pull request #148 from specklesystems/jrm/converter/fix Custom Properties overflow fix	2023-02-05 17:20:17 +00:00
Jedd Morgan	9fe12a018a	fix(ToNative): fixed issue with attaching custom properties that exceed int32 max value	2023-02-05 15:30:55 +00:00
JR-Morgan	8411c01f1b	Merge branch 'main' of https://github.com/specklesystems/speckle-blender	2023-02-02 15:06:25 +00:00
JR-Morgan	63b82a30cb	bumped specklepy 2.12.0	2023-02-02 15:05:59 +00:00
Jedd Morgan	0b6e39cf38	Merge pull request #147 from specklesystems/jrm/converter/multi-mesh Fixed misalgined uv error message	2023-02-02 13:56:21 +00:00
JR-Morgan	b7efcec517	uv experimentation	2023-02-02 13:45:57 +00:00
Jedd Morgan	0ab0096aac	Merge pull request #142 from specklesystems/jrm/converter/multi-mesh Jrm/converter/multi mesh	2023-02-01 14:00:11 +00:00
JR-Morgan	cbd8fc99bb	Merge remote-tracking branch 'origin' into jrm/converter/multi-mesh	2023-02-01 14:00:00 +00:00
JR-Morgan	2a9287e762	final polish	2023-02-01 13:52:20 +00:00
Jedd Morgan	98c70f237c	Merge pull request #146 from specklesystems/gergo/alwaysInstall fix(installer): make sure to always install specklepy dependencies	2023-02-01 13:10:22 +00:00
Gergő Jedlicska	048047cf05	fix(installer): make sure to always install specklepy dependencies Co-authored-by: Jedd Morgan <45512892+JR-Morgan@users.noreply.github.com>	2023-01-31 10:57:05 +02:00
Jedd Morgan	6118215cae	Experimentation with receive modes	2023-01-26 14:58:53 +00:00
Jedd Morgan	8e06432fe6	relock poetry	2023-01-23 23:50:42 +00:00
Jedd Morgan	cb8620ff8a	Merge branch 'main' into jrm/converter/multi-mesh Signed-off-by: Jedd Morgan <45512892+JR-Morgan@users.noreply.github.com>	2023-01-23 23:49:12 +00:00
Jedd Morgan	e0eddea8ab	Fixed regression of null elements	2023-01-23 19:59:49 +00:00
Jedd Morgan	8497d0c195	Merge pull request #144 from specklesystems/jrm/ifc/fix fixed IFC commits with empty lists	2023-01-20 17:00:04 +00:00
Jedd Morgan	1ce394c08f	fixed issue with IFC commits with empty lists	2023-01-20 15:31:44 +00:00
Jedd Morgan	aabbf87dda	fix(ci): signing cert for iss	2023-01-16 17:12:39 +00:00
Jedd Morgan	7e31787d37	Updated config.yml	2023-01-16 16:29:13 +00:00
Jedd Morgan	f1259587fd	Bumped speckle py to 2.11.4	2023-01-16 15:00:10 +00:00
Jedd Morgan	7f913e3af0	Merge pull request #141 from specklesystems/gergo/ciContextUpdate clone ci tools with ssh, use circleci context for env vars	2023-01-16 13:42:24 +00:00
Jedd Morgan	5433c34a4d	Merge pull request #140 from specklesystems/jrm/manual-installer Manual Installer	2023-01-16 13:39:50 +00:00
Alan Rynne	2c52e93660	ci: Updated github actions to use new actions repo	2023-01-09 20:41:22 +01:00
Gergő Jedlicska	3c3b24cf98	use innosetup context in the windows build	2023-01-06 14:01:56 +01:00
Gergő Jedlicska	3012b0ebcb	clone ci tools with ssh, use circleci context for env vars	2023-01-06 12:17:19 +01:00
Jedd Morgan	35b96eaa4e	feat(converter): meshes with multiple materials ToSpeckle	2022-12-19 13:42:35 +00:00
Jedd Morgan	c229bb2414	materials	2022-12-15 18:04:31 +00:00
Jedd Morgan	318bd086c0	feat(converter): convert displayValues ToNative as a single mesh	2022-12-15 16:00:44 +00:00
Jedd Morgan	e3eb29daa4	fiX(ci): fixed mistake in manual installer ci	2022-12-15 14:17:29 +00:00
Jedd Morgan	3359c8f275	feat(ci): Added manual instaler deploy	2022-12-14 17:01:45 +00:00
Gergő Jedlicska	cfc5007d00	update tag fiter for numbered alpha and beta	2022-12-14 11:20:00 +01:00
Jedd Morgan	0a630457be	Jrm/accounts reload (#138 ) * add new installer mechanism * ci(circleci): add new package connector step * ci(circleci): install dependencies before packaging * chore(deps): remove local specklepy dep * chore(deps): relock again * feat(connector): Added reload operation to user account selection * Zero restart installation Co-authored-by: Gergő Jedlicska <gergo@jedlicska.com>	2022-12-14 11:09:57 +01:00
Gergő Jedlicska	fa124c2312	gergo/newInstaller (#136 ) * add new installer mechanism * ci(circleci): add new package connector step * ci(circleci): install dependencies before packaging * chore(deps): remove local specklepy dep * chore(deps): relock again * ci(circleci): rewrite full ci WIP * fix(installer): ensure pip call was commented outy * ci(circleci): updates * ci(circleci): fix naming * ci(circleci): update filters * ci(circleci): update semver location * ci(circleci): update dependency graph * getting the specific installer branch * get proper ci tools * force remove new lines from installer tags * fix installer patch pathing * properly saving packaged zip * add python to dotnet installer * add zip again * only zip the published isntaller * publish only usefull stuff * ci(circleci): update details in deploy * ci(circleci): fix filters * ci(cirleci): fix mac build triggers * make sure semver is set * ci(circleci): fix env var restore in deploy * ci(circleci): fix missing semver in files * ci(circleci): wtf is microsoft doing with env vars in net6 containers? * ci(circleci): fix persist to workspace pathing * fix zipping dir * mkdir for the zip folder * mkdir -p * force copy * copy 101 * mkdir 101 * top level cp operation * pipe the zip * no CD * only parameter * build for osx 13 for arm * moving back to a mac build machine * fixc arm mac runtime * remove old linux installer build * allow alpha numbered version * remove ci tools branch	2022-12-14 10:55:44 +01:00
Jedd Morgan	977994e141	feat(converter): initial refactor of mesh traversal	2022-12-13 19:02:43 +00:00
Jedd Morgan	d9cbc80ee7	Zero restart installation	2022-12-09 15:00:44 +00:00
Jedd Morgan	45038fad79	feat(connector): Added reload operation to user account selection	2022-12-09 03:26:21 +00:00
Gergő Jedlicska	cda621d735	chore(deps): relock again	2022-12-07 14:46:09 +01:00
Gergő Jedlicska	2d052d1379	chore(deps): remove local specklepy dep	2022-12-07 14:44:20 +01:00
Gergő Jedlicska	46ce2bc0df	ci(circleci): install dependencies before packaging	2022-12-07 14:38:06 +01:00
Gergő Jedlicska	80e2216aa0	ci(circleci): add new package connector step	2022-12-07 14:32:48 +01:00
Gergő Jedlicska	10d69aa44b	add new installer mechanism	2022-12-07 13:52:22 +01:00
Jedd Morgan	b1481bd259	Merge pull request #135 from specklesystems/jrm/2.10-fixes Jrm/2.10 fixes	2022-11-30 20:40:01 +00:00
Jedd Morgan	e19fc9ef4e	fix(deployment): potential fix for mac releases	2022-11-30 20:38:43 +00:00
Jedd Morgan	448eb856b2	Bumped dependencies	2022-11-30 20:36:07 +00:00
Jedd Morgan	06a7d416c7	Merge pull request #134 from specklesystems/jrm/2.10-fixes fix(converter): fixed issue with meshes with very high number of vert…	2022-11-30 20:32:42 +00:00
Jedd Morgan	0753436899	fix(converter): fixed issue with meshes with very high number of verts taking an eternity to send Changed from using sum to extend list functions	2022-11-29 23:54:28 +00:00
Jedd Morgan	40e0a49b11	Merge pull request #130 from specklesystems/jrm/clean-mesh-fix fix(receive): Fixed issue with Clean Mesh creating duplicated collection	2022-11-17 16:05:56 +00:00
JR-Morgan	b17b9c9de4	fix(receive): Fixed issue with Clean Mesh creating duplicated collection	2022-11-17 14:45:17 +00:00
Jedd Morgan	f035111ffa	Merge pull request #128 from specklesystems/fix-py39 Fixed issue with connector failing to load on Blender 2.93	2022-11-11 12:09:55 +00:00
JR-Morgan	fa073f754f	Merge remote-tracking branch 'origin' into fix-py39	2022-11-11 02:23:50 +00:00
Jedd Morgan	83919375f9	Merge pull request #129 from specklesystems/jrm/ci/macos MacOS CI	2022-11-11 02:22:49 +00:00
JR-Morgan	defb11bc89	fix: Fixed issue with connector on Blender 2.93 failing due to accidental use of unsupported python features	2022-11-11 02:13:19 +00:00
JR-Morgan	548b3ad352	CI fix for macos slugs	2022-10-24 21:48:25 +01:00
JR-Morgan	d2deecf099	added deploy steps for macos	2022-10-24 21:27:38 +01:00
JR-Morgan	fbda0110cd	fix(connector): 2.9.0 update	2022-10-11 18:43:36 +01:00
Jedd Morgan	ba9ad9ac07	Merge pull request #118 from specklesystems/gergo/workflowMetrics add workflow tracking to receive operations	2022-10-11 17:56:40 +01:00
Jedd Morgan	d13db2b44a	Merge pull request #117 from specklesystems/jrm/receive-script-update Jrm/receive script update	2022-10-11 17:54:33 +01:00
JR-Morgan	2c127c85f3	feat: Updated recieve scripts to use context rather than scene	2022-10-07 16:03:10 +01:00
Gergő Jedlicska	cc099c0ff1	add workflow tracking to receive operations	2022-10-07 16:08:27 +02:00
JR-Morgan	448ab70c3b	Merge remote-tracking branch 'origin/jrm/clean-mesh' into jrm/receive-script-update	2022-10-04 18:28:57 +01:00
JR-Morgan	020eba2727	Merge remote-tracking branch 'origin/main' into jrm/receive-script-update	2022-10-04 17:53:01 +01:00
JR-Morgan	d8117e2c30	feat(converter): Updated Recieve Script callback functions to allow for access to Base object, and for callback on ToNative completion	2022-10-04 17:50:57 +01:00
Matteo Cominetti	57a6d88e6b	ci	2022-09-27 10:27:50 +01:00
Matteo Cominetti	74cb3e5f85	ci: change shell	2022-09-27 10:15:58 +01:00
Matteo Cominetti	d0aeecc863	Update README.md	2022-09-27 10:08:55 +01:00
Matteo Cominetti	2803308c5e	Update README.md	2022-09-27 10:08:06 +01:00
Matteo Cominetti	326f04f67d	ci: adds signtool param	2022-09-27 10:07:01 +01:00
JR-Morgan	68972ba8f9	Merge remote-tracking branch 'origin' into jrm/clean-mesh	2022-09-23 13:58:07 +01:00
Alan Rynne	73a028b56f	Merge pull request #112 from specklesystems/ci/force-run ci: Activated both mac runs on build	2022-09-23 14:56:02 +02:00
Alan Rynne	33890ef0ee	fix: went too far	2022-09-23 14:28:51 +02:00
Alan Rynne	53fe676ab6	ci: Prettified steps	2022-09-23 14:27:50 +02:00
Alan Rynne	f027c7eca4	ci: Activated both mac runs on build	2022-09-23 14:11:19 +02:00
JR-Morgan	ea2b6dfb0e	feat(connector): Added clean mesh option to recieve geometry with limited disolve + merge verts	2022-09-23 12:36:55 +01:00
JR-Morgan	83610cec38	Added type hinting to codebase	2022-09-21 22:22:07 +01:00
izzy lyseggen	2ed0685b10	fix(ci): soz just me clowning w regex (#108 )	2022-08-26 12:09:51 +01:00
izzy lyseggen	877e616188	ci: temp remove mac steps and clean tags (#107 )	2022-08-26 12:04:14 +01:00
izzy lyseggen	2e3e258a9a	ci: deploy to manager 2 (#106 ) * ci: add manager 2 feed * ci: update manager2 requirements	2022-08-26 11:47:50 +01:00
izzy lyseggen	1e1c790eb4	ci: blender mac pt 2 electric boogaloo (#100 ) * ci: build mac installers for both intel & arm * ci: fix conditional logic? * ci: final cleanup	2022-06-29 17:04:49 +01:00
izzy lyseggen	2148fe8dee	ci: fix deploy job names	2022-06-29 15:07:47 +01:00
izzy lyseggen	41c87a8661	ci: clean up config and add blender 3.2 (#99 ) * chore: remove unused stuff * ci: split out pip install win job * ci: fix modules path * ci: try reusable command instead * ci: fix shell specify syntax * ci: try only mior ver for upgrade py * ci: specify full py version * ci: separate mac and build w tags * ci: fix branch filter * ci: rename deploy jobs	2022-06-29 15:05:40 +01:00
izzy lyseggen	96c9add526	ci: update version patch script	2022-06-21 16:20:25 +01:00
izzy lyseggen	f425316e60	fix(converter): pass brep materials to displayvals (#96 ) * chore: bump py version to >=3.8 no need for old versions, and gives us some nice syntax * refactor(ui): remove some superficial units stuff * fix(converter): pass brep materials to displayvals this only passes the `renderMaterial` and it assumes all items in the brep's `displayValue` are meshes	2022-06-17 12:40:52 +01:00
izzy lyseggen	abf363894e	fix(ci): relax regex on the script	2022-06-15 14:46:44 +01:00
izzy lyseggen	8fc8b97b7a	fix(ci): another patching fix oop	2022-06-15 14:38:04 +01:00
izzylys	64b4175585	fix(ci): patch version script	2022-06-15 12:02:56 +01:00
izzy lyseggen	4eefda3305	ci: tag deploy trigger	2022-06-15 11:47:04 +01:00
izzy lyseggen	f7275140d5	ci: initial mac install ci (#95 ) * ci: initial mac install ci * ci: blender 3.1 mac support * ci: update brew so this worked on ssh let's see if it's ok now o.o * ci(mac): retry py3.10 symlink * ci: fix installer paths * ci: tags and patch ver * ci: mac syntax for python3! argh	2022-06-15 11:43:41 +01:00
izzy lyseggen	17a36f4fc2	ci: fix version tags again oops	2022-04-22 16:34:05 +01:00
izzy lyseggen	ba931e8205	fix(installer/metrics): updates and cleanup (#92 ) * ci: use semver tag instead of full circle tag * chore: update deps * chore: update specklepy * feat(metrics): add blender version	2022-04-22 11:58:47 +01:00
izzy lyseggen	572925cfbb	feat(convert): temps custom props patch (#89 ) * chore: bump specklepy and fix deps * feat(convert): wip attached props * feat(convert): wip custom props	2022-04-04 12:10:57 +01:00
izzy lyseggen	03f94d6371	fix(convert): breps and dates (#87 )	2022-03-28 15:03:27 +01:00
izzy lyseggen	c220337aec	chore: upgrade specklepy and add Blender v3.1 to ci (#86 ) * chore(specklepy): upgrade to 2.6.3 * ci: add py 3.10 for blender 3.1	2022-03-28 11:47:56 +01:00