feat(connector): Added clean mesh option to recieve geometry with limited disolve + merge verts

* ci: add manager 2 feed

* ci: update manager2 requirements

.circleci/config.yml

@@ -7,21 +7,25 @@ orbs:
   # Upload artifacts to s3
   aws-s3: circleci/aws-s3@2.0.0
 
-jobs:
-  build-connector: # Reusable job for basic connectors
-    executor:
-      name: win/default # comes with python 3.7.3
-      shell: cmd.exe
+commands:
+  install-specklepy-windows: # Reusable job for installing `specklepy` for windows machines
     parameters:
-      slug:
+      python-version:
         type: string
-        default: ""
+        default: "" # leave blank for blender v2.93
     steps:
-      - checkout
-      - attach_workspace:
-          at: ./
-      - run: 
-          name: Install specklepy with python 3.7
+      - when:
+          condition: << parameters.python-version >>
+          steps:
+            - run:
+                name: Upgrade python version << parameters.python-version >>
+                shell: powershell.exe
+                command: |
+                  choco upgrade python --version=<< parameters.python-version >>
+                  refreshenv
+                  python --version
+      - run:
+          name: Install specklepy into modules directory
           shell: powershell.exe
           command: |
             $pyarr=(python --version).split(' ')[1].split('.')
@@ -29,57 +33,143 @@ jobs:
             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 install python --version=3.9.2
-            $pyarr=(C:\Python39\python.exe --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            C:\Python39\python.exe -m pip install --target=./modules-$pyver specklepy==$specklepy
+
+jobs:
+  build-connector-win: # Reusable job for basic connectors
+    executor:
+      name: win/default # comes with python 3.7.3
+      shell: cmd.exe
+    parameters:
+      slug:
+        type: string
+        default: "blender"
+      installer:
+        type: boolean
+        default: false
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ./
+      - install-specklepy-windows
+      - install-specklepy-windows:
+          python-version: "3.9.10"
+      - install-specklepy-windows:
+          python-version: "3.10.2"
       - 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
+            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "0.0.0" } else { $env:CIRCLE_TAG }
+            $semver = if($tag.Contains('/')) {$tag.Split("/")[1] } else { $tag }
+            $ver = if($semver.Contains('-')) {$semver.Split("-")[0] } else { $semver }
+            $version = "$($ver).$($env:CIRCLE_BUILD_NUM)"
+            $channel = if($semver.Contains('-')) { "prerelease" } else { "latest" }
+            New-Item -Force "speckle-sharp-ci-tools/Installers/blender/$channel.yml" -ItemType File -Value "version: $semver"
+            echo $semver
+            python patch_version.py $semver
             speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools/Installers
+      - when:
+          condition: << parameters.installer >>
+          steps:
+            - 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>>"
+  build-connector-mac:
+    macos:
+      xcode: 12.5.1
     parameters:
-      tag:
-        default: "3.9"
+      slug:
         type: string
+        default: "blender-mac"
+      installername:
+        type: string
+        default: "SpeckleBlenderInstall"
+      runtime:
+        type: string
+        default: "osx-x64"
+      installer:
+        type: boolean
+        default: false
     steps:
       - checkout
+      - attach_workspace:
+          at: ./
       - run:
-          name: upgrade pip and install specklepy
+          name: Install mono
           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-*
-          
+            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:
+          name: Build & Patch Version
+          command: |
+            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "0.0.0"; fi;)
+            SEMVER=$(echo "$TAG" | sed -e 's/[a-zA-Z-]*\///')
+            VER=$(echo "$SEMVER" | sed -e 's/-beta//')
+            VERSION=$(echo $VER.$CIRCLE_BUILD_NUM)
+            CHANNEL=$(if [[ "$VERSION" == *"-"* ]]; then echo $(cut -d "-" -f2 \<\<\< $VERSION); else echo latest; fi)
+            mkdir -p speckle-sharp-ci-tools/Installers/<< parameters.slug >>
+            if [ "${CIRCLE_TAG}" ]; then echo "version: $SEMVER" > "speckle-sharp-ci-tools/Installers/<< parameters.slug >>/$CHANNEL.yml"; fi
+            python3 patch_version.py $SEMVER
+      # update python and package dependencies
+      - when:
+          condition:
+            and:
+              - << parameters.installer >>
+              - equal: [osx-x64, << parameters.runtime >>]
+          steps:
+            - run:
+                name: Install python 3.10
+                command: |
+                  brew install python@3.10
+                  brew link --overwrite python@3.10
+            - run:
+                name: Package specklepy dependencies for blender 3.1 & 3.2
+                command: |
+                  python3 --version
+                  python3 -m pip install --target=./modules-intel-3.10 specklepy==$(python3 -m patch_version)
+                  zip -r modules-intel-3.10.zip modules-intel-3.10/
+                  cp modules-intel-3.10.zip speckle-sharp-ci-tools/Mac/<<parameters.installername>>/.installationFiles
+      - run:
+          name: Zip Connector files
+          command: |
+            zip -r << parameters.slug >>.zip bpy_speckle/
+      - run:
+          name: Copy connector files to installer
+          command: |
+            mkdir -p speckle-sharp-ci-tools/Mac/<<parameters.installername>>/.installationFiles/
+            cp << parameters.slug >>.zip speckle-sharp-ci-tools/Mac/<<parameters.installername>>/.installationFiles
+            python3 patch_version.py > speckle-sharp-ci-tools/Mac/<<parameters.installername>>/.installationFiles/specklepy_ver.yml
+
+      - run:
+          name: Build Mac installer
+          command: ~/.dotnet/dotnet publish speckle-sharp-ci-tools/Mac/<<parameters.installername>>/<<parameters.installername>>.sln -r << parameters.runtime >> -c Release
+      - run:
+          name: Zip installer
+          command: |
+            cd speckle-sharp-ci-tools/Mac/<<parameters.installername>>/bin/Release/net6.0/<< parameters.runtime >>/
+            zip -r << parameters.slug >>.zip ./
+      - store_artifacts:
+          path: speckle-sharp-ci-tools/Mac/<<parameters.installername>>/bin/Release/net6.0/<< parameters.runtime >>/<< parameters.slug >>.zip
+      - run:
+          name: Copy to installer location
+          command: |
+            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "0.0.0"; fi;)
+            SEMVER=$(echo "$TAG" | sed -e 's/[a-zA-Z-]*\///')
+            cp speckle-sharp-ci-tools/Mac/<<parameters.installername>>/bin/Release/net6.0/<< parameters.runtime >>/<< parameters.slug >>.zip speckle-sharp-ci-tools/Installers/<< parameters.slug >>/<< parameters.slug >>-$SEMVER.zip
+      - when:
+          condition: << parameters.installer >>
+          steps:
+            - persist_to_workspace:
+                root: ./
+                paths:
+                  - speckle-sharp-ci-tools/Installers
+
   get-ci-tools: # Clones our ci tools and persists them to the workspace
     docker:
       - image: cimg/base:2021.01
@@ -109,34 +199,122 @@ jobs:
           from: '"speckle-sharp-ci-tools/Installers/"'
           to: s3://speckle-releases/installers/
 
+  deploy-manager2:
+    docker:
+      - image: mcr.microsoft.com/dotnet/sdk:6.0
+    parameters:
+      slug:
+        type: string
+      os:
+        type: string
+      extension:
+        type: string
+    steps:
+      - checkout
+      - attach_workspace:
+          at: ./
+      - run:
+          name: Install Manager Feed CLI
+          command: dotnet tool install --global Speckle.Manager.Feed
+      - run:
+          name: Upload new version
+          command: |
+            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "0.0.0"; fi;)
+            SEMVER=$(echo "$TAG" | sed -e 's/\/[a-zA-Z-]*//')
+            /root/.dotnet/tools/Speckle.Manager.Feed deploy -s << parameters.slug >> -v ${SEMVER} -u https://releases.speckle.dev/installers/<< parameters.slug >>/<< parameters.slug >>-${SEMVER}.<< parameters.extension >> -o << parameters.os >> -f speckle-sharp-ci-tools/Installers/<< parameters.slug >>/<< parameters.slug >>-${SEMVER}.<< parameters.extension >>
+
 workflows:
-  main:
+  build: # build the installers, but don't persist to workspace for deployment
+    jobs:
+      - get-ci-tools:
+          filters:
+            branches:
+              only:
+                - main
+                - /ci\/.*/
+      - build-connector-win:
+          requires:
+            - get-ci-tools
+          filters:
+            branches:
+              only:
+                - main
+                - /ci\/.*/
+      - build-connector-mac:
+          requires:
+            - get-ci-tools
+          filters:
+            branches:
+              only:
+                - main
+                - /ci\/.*/
+
+  deploy: # build installers and deploy
     jobs:
       - get-ci-tools:
           filters:
             tags:
               only: /.*/
             branches:
-              only:
-                - main
-                - /ci\/.*/
-      - build-connector:
+              ignore: /.*/
+
+      - build-connector-win:
+          name: build-deploy-connector-win
           slug: blender
+          installer: true
           requires:
             - get-ci-tools
           filters:
             tags:
-              only: /.*/
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
             branches:
-              only:
-                - main
-                - /ci\/.*/
+              ignore: /.*/
+
+      # - build-connector-mac:
+      #     name: build-deploy-connector-mac-arm
+      #     slug: blender-mac-arm
+      #     runtime: osx-arm64
+      #     installer: true
+      #     requires:
+      #       - get-ci-tools
+      #     filters:
+      #       tags:
+      #         only: /^(all|mac)\/([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
+      #       branches:
+      #         ignore: /.*/
+
+      # - build-connector-mac:
+      #     name: build-deploy-connector-mac-intel
+      #     slug: blender-mac-intel
+      #     runtime: osx-x64
+      #     installer: true
+      #     requires:
+      #       - get-ci-tools
+      #     filters:
+      #       tags:
+      #         only: /^(all|mac)\/([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
+      #       branches:
+      #         ignore: /.*/
+
       - deploy:
           requires:
             - get-ci-tools
-            - build-connector
+            - build-deploy-connector-win
           filters:
             tags:
-              only: /[0-9]+(\.[0-9]+)*/
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
+            branches:
+              ignore: /.*/
+
+      - deploy-manager2:
+          slug: blender
+          os: Win
+          extension: exe
+          requires:
+            - get-ci-tools
+            - deploy
+          filters:
+            tags:
+              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
             branches:
               ignore: /.*/ # For testing only! /ci\/.*/

bpy_speckle/__init__.py

@@ -1,25 +1,4 @@
-# MIT License
-
-# Copyright (c) 2018-2021 Tom Svilans
-
-# 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.
-
+import bpy
 
 bl_info = {
     "name": "SpeckleBlender 2.0",
@@ -33,21 +12,7 @@ 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
@@ -67,7 +32,6 @@ Add load handler to initialize Speckle when
 loading a Blender file
 """
 
-
 @persistent
 def load_handler(dummy):
     bpy.ops.speckle.users_load()
@@ -95,7 +59,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

bpy_speckle/clients.py

@@ -1,4 +1,7 @@
 """
 Permanent handle on all user clients
 """
-speckle_clients = []
+from specklepy.api.client import SpeckleClient
+
+
+speckle_clients: list[SpeckleClient] = []

bpy_speckle/convert/__init__.py

@@ -1,9 +1,10 @@
 from bpy_speckle.convert.to_native import convert_to_native
+from specklepy.objects.base import Base
 
-
-def get_speckle_subobjects(attr, scale, name):
+def get_speckle_subobjects(attr: dict | Base, scale: float, name: str) -> list:
     subobjects = []
-    for key in attr.keys():
+    keys = attr.keys() if isinstance(attr, dict) else attr.get_dynamic_member_names()
+    for key in keys:
         if isinstance(attr[key], dict):
             subtype = attr[key].get("type", None)
             if subtype:

bpy_speckle/convert/to_native.py

@@ -4,6 +4,7 @@ import mathutils
 import bpy, bmesh, bpy_types
 from specklepy.objects.other import *
 from specklepy.objects.geometry import *
+from bpy.types import Object
 from .util import (
     add_blender_material,
     add_custom_properties,
@@ -25,52 +26,69 @@ CAN_CONVERT_TO_NATIVE = (
 )
 
 
-def can_convert_to_native(speckle_object):
+def can_convert_to_native(speckle_object: Base) -> bool:
     if type(speckle_object) in CAN_CONVERT_TO_NATIVE:
         return True
-    display = getattr(
-        speckle_object, "displayMesh", getattr(speckle_object, "displayValue", None)
-    )
-    if display:
+    if getattr(
+        speckle_object, "displayValue", getattr(speckle_object, "displayMesh", None)
+    ):
         return True
 
     _report(f"Could not convert unsupported Speckle object: {speckle_object}")
     return False
 
 
-def convert_to_native(speckle_object, name=None):
+def convert_to_native(speckle_object: Base, name: str = None) -> list | Object:
     speckle_type = type(speckle_object)
     speckle_name = (
         name
         or getattr(speckle_object, "name", None)
-        or speckle_object.speckle_type + f" -- {speckle_object.id}"
+        or f"{speckle_object.speckle_type} -- {speckle_object.id}"
     )
+    # convert unsupported types with display values
     if speckle_type not in CAN_CONVERT_TO_NATIVE:
+        elements = getattr(speckle_object, "elements", []) or []
         display = getattr(
-            speckle_object, "displayMesh", getattr(speckle_object, "displayValue", None)
+            speckle_object, "displayValue", getattr(speckle_object, "displayMesh", None)
         )
-        if not display:
+        if not elements and not display:
             _report(f"Could not convert unsupported Speckle object: {speckle_object}")
-            return
+            return None
+        if isinstance(display, list):
+            elements.extend(display)
+        else:
+            elements.append(display)
+        # TODO: depreciate the parent type
         # add parent type here so we can use it as a blender custom prop
         # not making it hidden, so it will get added on send as i think it might be helpful? can reconsider
-        if isinstance(display, list):
-            for item in display:
-                item.parent_speckle_type = speckle_object.speckle_type
-                convert_to_native(item)
-        else:
-            display.parent_speckle_type = speckle_object.speckle_type
-            return convert_to_native(display, speckle_name)
-
-    units = getattr(speckle_object, "units", None)
-    if units:
-        scale = get_scale_length(units) / bpy.context.scene.unit_settings.scale_length
-
+        converted = []
+        for item in elements:
+            item.parent_speckle_type = speckle_object.speckle_type
+            blender_object = convert_to_native(item)
+            if isinstance(blender_object, list):
+                converted.extend(blender_object)
+            else:
+                add_custom_properties(speckle_object, blender_object)
+                converted.append(blender_object)
+        return converted
+        
     try:
+        # convert breps
+        if speckle_type is Brep:
+            meshes = getattr(
+                speckle_object, "displayValue", getattr(speckle_object, "displayMesh", None)
+            )
+            if material := getattr(speckle_object, "renderMaterial", getattr(speckle_object, "@renderMaterial", None),):
+                for mesh in meshes:
+                    mesh["renderMaterial"] = material
+
+            return [convert_to_native(mesh) for mesh in meshes]
+
+        if units := getattr(speckle_object, "units", None):
+            scale = get_scale_length(units) / bpy.context.scene.unit_settings.scale_length
+        # convert supported geometry
         if speckle_type is Mesh:
             obj_data = mesh_to_native(speckle_object, name=speckle_name, scale=scale)
-        elif speckle_type is Brep:
-            obj_data = brep_to_native(speckle_object, name=speckle_name, scale=scale)
         elif speckle_type in SUPPORTED_CURVES:
             obj_data = icurve_to_native(speckle_object, name=speckle_name, scale=scale)
         elif speckle_type is Transform:
@@ -113,14 +131,7 @@ def convert_to_native(speckle_object, name=None):
     return blender_object
 
 
-def brep_to_native(speckle_brep, name, scale=1.0):
-    display = getattr(
-        speckle_brep, "displayMesh", getattr(speckle_brep, "displayValue", None)
-    )
-    return mesh_to_native(display, name, scale) if display else None
-
-
-def mesh_to_native(speckle_mesh, name, scale=1.0):
+def mesh_to_native(speckle_mesh: Mesh, name: str, scale=1.0) -> bpy.types.Mesh:
 
     if name in bpy.data.meshes.keys():
         blender_mesh = bpy.data.meshes[name]
@@ -140,8 +151,7 @@ def mesh_to_native(speckle_mesh, name, scale=1.0):
 
     return blender_mesh
 
-
-def line_to_native(speckle_curve, blender_curve, scale):
+def line_to_native(speckle_curve: Line, blender_curve: bpy.types.Curve, scale: float) -> bpy.types.Spline | None:
     line = blender_curve.splines.new("POLY")
     line.points.add(1)
 
@@ -164,12 +174,8 @@ def line_to_native(speckle_curve, blender_curve, scale):
         return line
 
 
-def polyline_to_native(scurve, bcurve, scale):
-
-    # value = find_key_case_insensitive(scurve, "value")
-    value = scurve.value
-
-    if value:
+def polyline_to_native(scurve: Polyline, bcurve: bpy.types.Curve, scale: float) -> bpy.types.Spline | None:
+    if value := scurve.value:
         N = len(value) // 3
 
         polyline = bcurve.splines.new("POLY")
@@ -192,12 +198,8 @@ def polyline_to_native(scurve, bcurve, scale):
         return polyline
 
 
-def nurbs_to_native(scurve, bcurve, scale):
-
-    # points = find_key_case_insensitive(scurve, "points")
-    points = scurve.points
-
-    if points:
+def nurbs_to_native(scurve: Curve, bcurve: bpy.types.Curve, scale: float) -> bpy.types.Spline | None:
+    if points := scurve.points:
         N = len(points) // 3
 
         nurbs = bcurve.splines.new("NURBS")
@@ -225,12 +227,12 @@ def nurbs_to_native(scurve, bcurve, scale):
         return nurbs
 
 
-def arc_to_native(rcurve, bcurve, scale):
+def arc_to_native(rcurve: Arc, bcurve: bpy.types.Curve, scale: float) -> bpy.types.Spline | None:
     # TODO: improve Blender representation of arc
 
     plane = rcurve.plane
     if not plane:
-        return
+        return None
 
     normal = mathutils.Vector([plane.normal.x, plane.normal.y, plane.normal.z])
 
@@ -287,7 +289,7 @@ def arc_to_native(rcurve, bcurve, scale):
     return arc
 
 
-def polycurve_to_native(scurve, bcurve, scale):
+def polycurve_to_native(scurve: Polycurve, bcurve: bpy.types.Curve, scale: float):
     """
     Convert Polycurve object
     """
@@ -306,7 +308,7 @@ def polycurve_to_native(scurve, bcurve, scale):
     return curves
 
 
-def icurve_to_native_spline(speckle_curve, blender_curve, scale=1.0):
+def icurve_to_native_spline(speckle_curve: Base, blender_curve: bpy.types.Curve, scale=1.0):
     curve_type = type(speckle_curve)
     if curve_type is Line:
         return line_to_native(speckle_curve, blender_curve, scale)
@@ -320,7 +322,7 @@ def icurve_to_native_spline(speckle_curve, blender_curve, scale=1.0):
         return arc_to_native(speckle_curve, blender_curve, scale)
 
 
-def icurve_to_native(speckle_curve, name=None, scale=1.0):
+def icurve_to_native(speckle_curve: Base, name=None, scale=1.0) -> Curve | None:
     curve_type = type(speckle_curve)
     if curve_type not in SUPPORTED_CURVES:
         _report(f"Unsupported curve type: {curve_type}")
@@ -339,7 +341,7 @@ def icurve_to_native(speckle_curve, name=None, scale=1.0):
     return blender_curve
 
 
-def transform_to_native(transform: Transform, scale=1.0):
+def transform_to_native(transform: Transform, scale=1.0) -> mathutils.Matrix:
     mat = mathutils.Matrix(
         [
             transform.value[:4],
@@ -354,7 +356,7 @@ def transform_to_native(transform: Transform, scale=1.0):
     return mat
 
 
-def block_def_to_native(definition: BlockDefinition, scale=1.0):
+def block_def_to_native(definition: BlockDefinition, scale=1.0) -> bpy.types.Collection:
     native_def = bpy.data.collections.get(definition.name)
     if native_def:
         return native_def
@@ -362,8 +364,7 @@ def block_def_to_native(definition: BlockDefinition, scale=1.0):
     native_def = bpy.data.collections.new(definition.name)
     native_def["applicationId"] = definition.applicationId
     for geo in definition.geometry:
-        b_obj = convert_to_native(geo)
-        if b_obj:
+        if b_obj := convert_to_native(geo):
             native_def.objects.link(
                 b_obj
                 if isinstance(b_obj, bpy_types.Object)
@@ -373,7 +374,7 @@ def block_def_to_native(definition: BlockDefinition, scale=1.0):
     return native_def
 
 
-def block_instance_to_native(instance: BlockInstance, scale=1.0):
+def block_instance_to_native(instance: BlockInstance, scale=1.0) -> bpy.types.Object:
     """
     Convert BlockInstance to native
     """
@@ -381,6 +382,8 @@ def block_instance_to_native(instance: BlockInstance, scale=1.0):
     native_def = block_def_to_native(instance.blockDefinition, scale)
 
     native_instance = bpy.data.objects.new(name, None)
+    add_custom_properties(instance, native_instance)
+    native_instance["name"] = getattr(instance, 'name', None) or instance.blockDefinition.name
     # hide the instance axes so they don't clutter the viewport
     native_instance.empty_display_size = 0
     native_instance.instance_collection = native_def

bpy_speckle/convert/to_speckle.py

@@ -1,4 +1,5 @@
 import bpy
+from bpy.types import MeshVertColor, MeshVertex, Object
 from specklepy.objects.geometry import Mesh, Curve, Interval, Box, Point, Polyline
 from specklepy.objects.other import *
 from bpy_speckle.functions import _report
@@ -13,10 +14,12 @@ UNITS = "m"
 CAN_CONVERT_TO_SPECKLE = ("MESH", "CURVE", "EMPTY")
 
 
-def convert_to_speckle(blender_object, scale, desgraph=None):
+def convert_to_speckle(blender_object: Object, scale: float, units: str, desgraph=None) -> list | None:
+    global UNITS
+    UNITS = units
     blender_type = blender_object.type
     if blender_type not in CAN_CONVERT_TO_SPECKLE:
-        return
+        return None
 
     speckle_objects = []
     speckle_material = material_to_speckle(blender_object)
@@ -52,10 +55,11 @@ def convert_to_speckle(blender_object, scale, desgraph=None):
     return speckle_objects
 
 
-def mesh_to_speckle(blender_object, data, scale=1.0):
+def mesh_to_speckle(blender_object: Object, data: bpy.types.Mesh, scale=1.0) -> List[Mesh]:
     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]
@@ -69,7 +73,7 @@ def mesh_to_speckle(blender_object, data, scale=1.0):
         faces=[],
         colors=[],
         textureCoordinates=[],
-        units="m" if unit_system == "METRIC" else "ft",
+        units=UNITS,
         bbox=Box(area=0.0, volume=0.0),
     )
 
@@ -87,10 +91,16 @@ def mesh_to_speckle(blender_object, data, scale=1.0):
             sm.faces.append(n)
         sm.faces.extend(f)
 
+    # TODO: figure out how to align vertex colors and vertices consistantly in receiving applications
+    # we are seeing the same issue as with texture coordinate alignment
+    #if data.color_attributes.active_color:
+    #    sm.colors = [to_argb_int(x.color) for x in data.color_attributes.active_color.data]
+            
+
     return [sm]
 
 
-def bezier_to_speckle(matrix, spline, scale, name=None):
+def bezier_to_speckle(matrix: List[float], spline: bpy.types.Spline, scale: float, name:str = None) -> Curve:
     degree = 3
     closed = spline.use_cyclic_u
 
@@ -103,9 +113,13 @@ def bezier_to_speckle(matrix, spline, scale, name=None):
             points.append(tuple(matrix @ bp.handle_right * scale))
 
     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 * scale),
+                tuple(matrix @ spline.bezier_points[0].handle_left * scale),
+                tuple(matrix @ spline.bezier_points[0].co * scale),
+            )
+        )
 
     num_points = len(points)
 
@@ -135,7 +149,7 @@ def bezier_to_speckle(matrix, spline, scale, name=None):
     )
 
 
-def nurbs_to_speckle(matrix, spline, scale, name=None):
+def nurbs_to_speckle(matrix: List[float], spline: bpy.types.Spline, scale: float, name:str = None) -> Curve:
     knots = make_knots(spline)
     points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
     degree = spline.order_u - 1
@@ -161,14 +175,14 @@ def nurbs_to_speckle(matrix, spline, scale, name=None):
     )
 
 
-def poly_to_speckle(matrix, spline, scale, name=None):
+def poly_to_speckle(matrix: List[float], spline: bpy.types.Spline, scale: float, name: str = None) -> Polyline:
     points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
 
     length = spline.calc_length()
     domain = Interval(start=0, end=length, totalChildrenCount=0)
     return Polyline(
         name=name,
-        closed=spline.use_cyclic_u,
+        closed=bool(spline.use_cyclic_u),
         value=list(sum(points, ())),  # magic (flatten list of tuples)
         length=length,
         domain=domain,
@@ -178,7 +192,7 @@ def poly_to_speckle(matrix, spline, scale, name=None):
     )
 
 
-def icurve_to_speckle(blender_object, data, scale=1.0):
+def icurve_to_speckle(blender_object: Object, data: bpy.types.Curve, scale=1.0) -> List[Base] | None:
     UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
 
     if blender_object.type != "CURVE":
@@ -207,7 +221,7 @@ def icurve_to_speckle(blender_object, data, scale=1.0):
     return curves
 
 
-def ngons_to_speckle_polylines(blender_object, data, scale=1.0):
+def ngons_to_speckle_polylines(blender_object: Object, data: bpy.types.Mesh, scale=1.0) -> List[Polyline] | None:
     UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
 
     if blender_object.type != "MESH":
@@ -239,16 +253,21 @@ def ngons_to_speckle_polylines(blender_object, data, scale=1.0):
     return polylines
 
 
-def material_to_speckle(blender_object) -> RenderMaterial:
+def material_to_speckle(blender_object: Object) -> RenderMaterial | None:
     """Create and return a render material from a blender object"""
     if not getattr(blender_object.data, "materials", None):
-        return
+        return None
+
+    blender_mat: bpy.types.Material = blender_object.data.materials[0]
+    if not blender_mat:
+        return None
 
-    blender_mat = blender_object.data.materials[0]
     speckle_mat = RenderMaterial()
     speckle_mat.name = blender_mat.name
 
-    if blender_mat.use_nodes is True:
+    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)
@@ -264,20 +283,19 @@ def material_to_speckle(blender_object) -> RenderMaterial:
     return speckle_mat
 
 
-def transform_to_speckle(blender_transform, scale=1.0):
-    units = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
+def transform_to_speckle(blender_transform: List[float], scale=1.0) -> Transform:
     value = [y for x in blender_transform for y in x]
     # scale the translation
     for i in (3, 7, 11):
         value[i] *= scale
 
-    return Transform(value=value, units=units)
+    return Transform(value=value, units=UNITS)
 
 
-def block_def_to_speckle(blender_definition, scale=1.0):
+def block_def_to_speckle(blender_definition: bpy.types.Collection, scale=1.0) -> BlockDefinition:
     geometry = []
     for geo in blender_definition.objects:
-        geometry.extend(convert_to_speckle(geo, scale))
+        geometry.extend(convert_to_speckle(geo, scale, UNITS))
     block_def = BlockDefinition(
         units=UNITS,
         name=blender_definition.name,
@@ -289,7 +307,7 @@ def block_def_to_speckle(blender_definition, scale=1.0):
     return block_def
 
 
-def block_instance_to_speckle(blender_instance, scale=1.0):
+def block_instance_to_speckle(blender_instance: Object, scale=1.0):
     return BlockInstance(
         blockDefinition=block_def_to_speckle(
             blender_instance.instance_collection, scale
@@ -300,7 +318,7 @@ def block_instance_to_speckle(blender_instance, scale=1.0):
     )
 
 
-def empty_to_speckle(blender_object, scale=1.0):
+def empty_to_speckle(blender_object: Object, scale=1.0) -> BlockInstance | None:
     # probably an instance collection (block) so let's try it
     try:
         geo = blender_object.instance_collection.objects.items()

bpy_speckle/convert/util.py

@@ -1,9 +1,28 @@
-import base64
+import math
 from typing import Tuple
+from bmesh.types import BMesh
 import bpy, struct, idprop
 
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Mesh
 from specklepy.serialization.base_object_serializer import BaseObjectSerializer
 from bpy_speckle.functions import _report
+from bpy.types import Object
+
+IGNORED_PROPERTY_KEYS = {
+    "id",
+    "elements",
+    "displayMesh",
+    "displayValue",
+    "speckle_type",
+    "parameters",
+    "faces",
+    "colors",
+    "vertices",
+    "renderMaterial",
+    "textureCoordinates",
+    "totalChildrenCount"
+}
 
 
 def to_rgba(argb_int: int) -> Tuple[float]:
@@ -23,8 +42,7 @@ def to_argb_int(diffuse_colour) -> int:
 
     return int.from_bytes(diffuse_colour, byteorder="big", signed=True)
 
-
-def add_custom_properties(speckle_object, blender_object):
+def add_custom_properties(speckle_object: Base, blender_object: Object):
     if blender_object is None:
         return
 
@@ -34,15 +52,28 @@ def add_custom_properties(speckle_object, blender_object):
     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)):
+            blender_object[key] = val
+        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:
+                blender_object[key] = items
+        elif isinstance(val,dict):
+            for (k,v) in val.items():
+                if not isinstance(v, Base):
+                    blender_object[k] = v            
 
 
-def add_blender_material(speckle_object, blender_object) -> None:
+def add_blender_material(speckle_object: Base, blender_object: Object) -> None:
     """Add material to a blender object if the corresponding speckle object has a render material"""
     if blender_object.data is None:
         return
@@ -80,7 +111,7 @@ def add_blender_material(speckle_object, blender_object) -> None:
     blender_object.data.materials.append(blender_mat)
 
 
-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:
@@ -96,7 +127,7 @@ 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, smooth=False):
     sfaces = speckle_mesh.faces
 
     if sfaces and len(sfaces) > 0:
@@ -120,7 +151,7 @@ def add_faces(speckle_mesh, blender_mesh, smooth=False):
         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
 
@@ -151,74 +182,66 @@ def add_colors(speckle_mesh, blender_mesh):
                     loop[color_layer] = colors[loop.vert.index]
 
 
-def add_uv_coords(speckle_mesh, blender_mesh):
-    if not hasattr(speckle_mesh, "properties"):
+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):
+            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 * 2: {len(s_uvs) * 2}"
+            )
+            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:
+            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:
         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)):
+    if isinstance(obj, (list, tuple, idprop.types.IDPropertyArray)):
         return [get_blender_custom_properties(o, max_depth - 1) for o in obj]
-    else:
-        return obj
+    
+    return obj
 
 
 """

bpy_speckle/functions.py

@@ -33,7 +33,7 @@ def _report(msg):
     print("SpeckleBlender: {}".format(msg))
 
 
-def get_scale_length(units):
+def get_scale_length(units: str) -> float:
     if units.lower() in unit_scale.keys():
         return unit_scale[units]
     _report("Units <{}> are not supported.".format(units))

bpy_speckle/install_dependencies.py

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

bpy_speckle/operators/object.py

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

bpy_speckle/operators/streams.py

@@ -2,7 +2,8 @@
 Stream operators
 """
 from itertools import chain
-from typing import Dict
+from math import radians
+from typing import Callable, Dict, Iterable
 import bpy
 from specklepy.api.models import Commit
 import webbrowser
@@ -10,6 +11,7 @@ from bpy.props import (
     StringProperty,
     BoolProperty,
 )
+from bpy.types import Object
 from bpy_speckle.convert.to_native import can_convert_to_native, convert_to_native
 from bpy_speckle.convert.to_speckle import (
     convert_to_speckle,
@@ -25,14 +27,14 @@ from bpy_speckle.clients import speckle_clients
 from bpy_speckle.operators.users import add_user_stream
 
 from specklepy.api import operations
-from specklepy.api.credentials import StreamWrapper
+from specklepy.api.wrapper import StreamWrapper
 from specklepy.api.resources.stream import Stream
 from specklepy.transports.server import ServerTransport
 from specklepy.objects.geometry import *
 from specklepy.logging.exceptions import SpeckleException
 
 
-def get_objects_collections(base) -> Dict:
+def get_objects_collections(base: Base) -> Dict[str, list]:
     """Create collections based on the dynamic members on a root commit object"""
     collections = {}
     for name in base.get_dynamic_member_names():
@@ -47,7 +49,7 @@ def get_objects_collections(base) -> Dict:
     return collections
 
 
-def get_objects_nested_lists(items, parent_col=None) -> List:
+def get_objects_nested_lists(items: list, parent_col: bpy.types.Collection = None) -> List:
     """For handling the weird nested lists that come from Grasshopper"""
     objects = []
 
@@ -64,7 +66,7 @@ def get_objects_nested_lists(items, parent_col=None) -> List:
     return objects
 
 
-def get_objects_collections_recursive(base, parent_col=None) -> List:
+def get_objects_collections_recursive(base: Base, parent_col: bpy.types.Collection = None) -> List:
     """Recursively create collections based on the dynamic members on nested `Base` objects within the root commit object"""
     # if it's a convertable (registered) class and not just a plain `Base`, return the object itself
     if can_convert_to_native(base):
@@ -75,10 +77,10 @@ def get_objects_collections_recursive(base, parent_col=None) -> List:
 
     for name in base.get_dynamic_member_names():
         value = base[name]
+        if name == "parameters" and "Revit" in base.speckle_type:
+            continue
         if isinstance(value, list):
-            for item in value:
-                if isinstance(item, Base):
-                    objects.append(item)
+            objects.extend(item for item in value if isinstance(item, Base))
         if isinstance(value, Base):
             col = parent_col.children.get(name)
             if not col:
@@ -94,7 +96,7 @@ def get_objects_collections_recursive(base, parent_col=None) -> List:
     return objects
 
 
-def bases_to_native(context, collections, scale, stream_id, func=None):
+def bases_to_native(context: bpy.types.Context, collections: Dict[str, list], scale: float, stream_id: str, func: Callable = None):
     for col_name, objects in collections.items():
         col = bpy.data.collections[col_name]
         existing = get_existing_collection_objs(col)
@@ -126,8 +128,11 @@ def bases_to_native(context, collections, scale, stream_id, func=None):
                 context.area.tag_redraw()
 
 
-def base_to_native(context, base, scale, stream_id, col, existing, func=None):
-    new_objects = [convert_to_native(base)]
+
+def base_to_native(context: bpy.types.Context, base: Base, scale: float, stream_id: str, col: bpy.types.Collection, existing: Dict[str, Object], func: Callable = None):
+    new_objects = convert_to_native(base)
+    if not isinstance(new_objects, list):
+        new_objects = [new_objects]
 
     if hasattr(base, "properties") and base.properties is not None:
         new_objects.extend(get_speckle_subobjects(base.properties, scale, base.id))
@@ -152,8 +157,7 @@ def base_to_native(context, base, scale, stream_id, col, existing, func=None):
         if (
             new_object is None
         ):  # Make sure that the injected function returned an object
-            new_obj = new_object
-            _report("Script '{}' returned None.".format(func.__module__))
+            _report(f"Script '{func.__module__}' returned None.")
             continue
 
         new_object.speckle.stream_id = stream_id
@@ -161,7 +165,7 @@ def base_to_native(context, base, scale, stream_id, col, existing, func=None):
 
         if new_object.speckle.object_id in existing.keys():
             name = existing[new_object.speckle.object_id].name
-            existing[new_object.speckle.object_id].name = name + "__deleted"
+            existing[new_object.speckle.object_id].name = f"{name}__deleted"
             new_object.name = name
             col.objects.unlink(existing[new_object.speckle.object_id])
 
@@ -169,7 +173,7 @@ def base_to_native(context, base, scale, stream_id, col, existing, func=None):
             col.objects.link(new_object)
 
 
-def create_collection(name, clear_collection=True):
+def create_collection(name: str, clear_collection=True) -> bpy.types.Collection:
     if name in bpy.data.collections:
         col = bpy.data.collections[name]
         if clear_collection:
@@ -181,13 +185,13 @@ def create_collection(name, clear_collection=True):
     return col
 
 
-def create_child_collections(parent_col, children_names):
+def create_child_collections(parent_col: bpy.types.Collection, children_names: Iterable[str]):
     for name in children_names:
         col = create_collection(name)
         parent_col.children.link(col)
 
 
-def get_existing_collection_objs(col):
+def get_existing_collection_objs(col: bpy.types.Collection) -> Dict[str, bpy.types.Object]:
     return {
         obj.speckle.object_id: obj for obj in col.objects if obj.speckle.object_id != ""
     }
@@ -239,6 +243,49 @@ class ReceiveStreamObjects(bpy.types.Operator):
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Receive objects from active stream"
 
+    
+    clean_meshes: BoolProperty(name="Clean Meshes", default=False)
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column()
+        col.prop(self, "clean_meshes")
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self)
+
+    @staticmethod
+    def clean_converted_meshes(context: bpy.types.Context, convertedObjects: dict[str, Object]):
+        
+        bpy.ops.object.select_all(action='DESELECT')
+
+        active = None
+        for obj in convertedObjects.values():
+            if obj.type != 'MESH':
+                continue
+
+            # This seems to be required inorder to select the object here
+            if obj.name not in context.scene.collection.objects:
+                context.scene.collection.objects.link(obj)
+
+            obj.select_set(True, view_layer=context.scene.view_layers[0])
+            active = obj
+        
+
+        if active == None:
+            return
+        context.view_layer.objects.active = active
+
+        bpy.ops.object.mode_set(mode='EDIT')
+        bpy.ops.mesh.select_all(action='SELECT')
+        bpy.ops.mesh.remove_doubles()
+        bpy.ops.mesh.dissolve_limited(angle_limit=radians(0.1))
+
+        # Reset state to previous (not quite sure if this is 100% necessary)
+        bpy.ops.object.mode_set(mode='OBJECT')
+        bpy.ops.object.select_all(action='DESELECT')
+        bpy.context.view_layer.objects.active = None
+
     def execute(self, context):
         bpy.context.view_layer.objects.active = None
 
@@ -250,7 +297,7 @@ class ReceiveStreamObjects(bpy.types.Operator):
 
         client = speckle_clients[int(context.scene.speckle.active_user)]
 
-        stream = client.stream.get(id=bstream.id)
+        stream = client.stream.get(id=bstream.id, branch_limit=20)
         if stream.branches.totalCount < 1:
             return {"CANCELLED"}
 
@@ -276,6 +323,9 @@ class ReceiveStreamObjects(bpy.types.Operator):
             message="received commit from Speckle Blender",
         )
 
+        context.window_manager.progress_begin(0, stream_data.totalChildrenCount)
+
+
         """
         Create or get Collection for stream objects
         """
@@ -308,20 +358,45 @@ class ReceiveStreamObjects(bpy.types.Operator):
         """
         Get script from text editor for injection
         """
-        func = None
+        userFunc = None
         if context.scene.speckle.receive_script in bpy.data.texts:
             mod = bpy.data.texts[context.scene.speckle.receive_script].as_module()
             if hasattr(mod, "execute"):
-                func = mod.execute
+                userFunc = mod.execute
+
+        createdObjects:Dict[str, Object] = {}
+
+        progress = 0
+        def func(scene, obj: Object):
+            nonlocal progress
+            nonlocal context
+            nonlocal createdObjects   
+                 
+            progress += 1 #TODO: Progress bar neverreaches 100 because func is only called for convertable objects
+            context.window_manager.progress_update(progress)
+            createdObjects[obj.name] = obj
+
+            if userFunc:
+                return userFunc(scene, obj)
+            else:
+                return obj
+        
 
         """
         Iterate through retrieved resources
         """
         bases_to_native(context, collections, scale, stream.id, func)
+        context.window_manager.progress_end()
+
+
+        if self.clean_meshes:
+            self.clean_converted_meshes(context, createdObjects)
+
 
         return {"FINISHED"}
 
 
+
 class SendStreamObjects(bpy.types.Operator):
     """
     Send stream objects
@@ -373,9 +448,14 @@ class SendStreamObjects(bpy.types.Operator):
 
         client = speckle_clients[int(context.scene.speckle.active_user)]
 
-        scale = context.scene.unit_settings.scale_length / get_scale_length(
-            stream.units.lower()
-        )
+        # scale = context.scene.unit_settings.scale_length / get_scale_length(
+        #     stream.units.lower()
+        # )
+        
+
+        scale = 1.0
+
+        units = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
 
         """
         Get script from text editor for injection
@@ -410,18 +490,19 @@ class SendStreamObjects(bpy.types.Operator):
 
             _report("Converting {}".format(obj.name))
 
-            ngons = obj.get("speckle_ngons_as_polylines", False)
+            # ngons = obj.get("speckle_ngons_as_polylines", False)
 
-            if ngons:
-                converted = ngons_to_speckle_polylines(obj, scale)
-            else:
-                converted = convert_to_speckle(
-                    obj,
-                    scale,
-                    bpy.context.evaluated_depsgraph_get()
-                    if self.apply_modifiers
-                    else None,
-                )
+            # if ngons:
+            #     converted = ngons_to_speckle_polylines(obj, scale)
+            # else:
+            converted = convert_to_speckle(
+                obj,
+                scale,
+                units,
+                bpy.context.evaluated_depsgraph_get()
+                if self.apply_modifiers
+                else None,
+            )
 
             if not converted:
                 continue
@@ -518,7 +599,7 @@ class AddStreamFromURL(bpy.types.Operator):
         user = speckle.users[user_index]
 
         client = speckle_clients[user_index]
-        stream = client.stream.get(wrapper.stream_id)
+        stream = client.stream.get(wrapper.stream_id, branch_limit=20)
         if not isinstance(stream, Stream):
             raise SpeckleException("Could not get the requested stream")
 

bpy_speckle/operators/users.py

@@ -5,7 +5,9 @@ import bpy
 from bpy_speckle.functions import _report
 from bpy_speckle.clients import speckle_clients
 from specklepy.api.client import SpeckleClient
+from specklepy.api.models import Stream, User
 from specklepy.api.credentials import get_local_accounts
+from datetime import datetime
 
 
 class LoadUsers(bpy.types.Operator):
@@ -58,7 +60,7 @@ class LoadUsers(bpy.types.Operator):
         return {"FINISHED"}
 
 
-def add_user_stream(user, stream):
+def add_user_stream(user: User, stream: Stream):
     s = user.streams.add()
     s.name = stream.name
     s.id = stream.id
@@ -78,10 +80,10 @@ def add_user_stream(user, stream):
         for c in b.commits.items:
             commit = branch.commits.add()
             commit.id = commit.name = c.id
-            commit.message = c.message
+            commit.message = c.message or ""
             commit.author_name = c.authorName
             commit.author_id = c.authorId
-            commit.created_at = c.createdAt
+            commit.created_at = datetime.strftime(c.createdAt, "%Y-%m-%d %H:%M:%S.%f%Z")
             commit.source_application = str(c.sourceApplication)
 
     if hasattr(s, "baseProperties"):
@@ -110,7 +112,7 @@ class LoadUserStreams(bpy.types.Operator):
             try:
                 streams = client.stream.list(stream_limit=20)
             except Exception as e:
-                _report("Failed to retrieve streams: {}".format(e))
+                _report(f"Failed to retrieve streams: {e}")
                 return
             if not streams:
                 _report("Failed to retrieve streams.")
@@ -121,7 +123,7 @@ class LoadUserStreams(bpy.types.Operator):
             default_units = "Meters"
 
             for s in streams:
-                sstream = client.stream.get(id=s.id)
+                sstream = client.stream.get(id=s.id, branch_limit=20)
                 add_user_stream(user, sstream)
 
             bpy.context.view_layer.update()

bpy_speckle/ui/view3d.py

@@ -12,7 +12,7 @@ from bpy.props import (
     EnumProperty,
 )
 
-import datetime
+from datetime import datetime
 
 """
 Compatibility 
@@ -177,7 +177,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 +205,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 +230,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()

patch_version.py

@@ -28,7 +28,8 @@ def patch_installer(tag):
     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')
+        lines.insert(12, f'#define AppVersion "{tag.split("-")[0]}"\n')
+        lines.insert(13, f'#define AppInfoVersion "{tag}"\n')
 
         with open(iss_file, "w") as file:
             file.writelines(lines)
@@ -54,11 +55,11 @@ def main():
         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_connector(tag.split("-")[0])
     patch_installer(tag)
 
 

pyproject.toml

@@ -6,14 +6,13 @@ authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>"]
 license = "Apache-2.0"
 
 [tool.poetry.dependencies]
-python = ">=3.7,<3.8"
-specklepy = "^2.5.1"
+python = ">=3.8, <4.0.0"
+specklepy = "^2.6.6"
 
 [tool.poetry.dev-dependencies]
 devtools = "^0.6.1"
 numpy = "^1.20.2"
-bpy = "^2.82.1"
-bpy-build = "^2.1.0"
+fake-bpy-module-latest = "^20220401"
 black = "^21.12b0"
 pylint = "^2.12.2"