use sectigo timestamp

Bilal/cnx 1650 integrating workspaces to blender dui

.circleci/config.yml

@@ -1,331 +1,17 @@
 version: 2.1
 
-orbs:
-  win: circleci/windows@5.0.0
-
+# Define the jobs we want to run for this project
 jobs:
-  package-connector:
+  build:
     docker:
-      - image: cimg/python:3.11.0
+      - image: cimg/base:2023.03
     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: &restore_semver
-          name: Restore Semver
-          command: SEMVER=$(cat ./SEMVER) && echo $SEMVER
-      - run:
-          name: Package to Zip
-          command: zip -r bpy_speckle.zip bpy_speckle
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - bpy_speckle.zip
-  
-  get-ci-tools: # Clones our ci tools and persists them to the workspace
-    docker:
-      - image: cimg/base:2021.01
-    steps:
-      - 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 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
-
-  build-installer-win:
-    executor:
-      name: win/default
-    environment:
-      SSM: 'C:\Program Files\DigiCert\DigiCert One Signing Manager Tools'
-    steps:
-      - attach_workspace:
-          at: ./
-      - run:
-          name: Patch installer
-          command: python patch_installer.py (Get-Content -Raw SEMVER)
-      - unless: # Build installers unsigned on non-tagged builds
-          condition: << pipeline.git.tag >>
-          steps:
-            - run:
-                name: Build Installer
-                command: speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss /Sbyparam=$p
-                shell: cmd.exe #does not work in powershell
-      - when: # Setup certificates and build installers signed for tagged builds
-          condition: << pipeline.git.tag >>
-          steps:
-            - run:
-                name: "Digicert Signing Manager Setup"
-                command: |
-                  cd C:\
-                  curl.exe -X GET  https://one.digicert.com/signingmanager/api-ui/v1/releases/smtools-windows-x64.msi/download -H "x-api-key:$env:SM_API_KEY" -o smtools-windows-x64.msi
-                  msiexec.exe /i smtools-windows-x64.msi /quiet /qn | Wait-Process
-            - run:
-                name: Create Auth & OV Signing Cert
-                command: |
-                  cd C:\
-                  echo $env:SM_CLIENT_CERT_FILE_B64 > certificate.txt
-                  certutil -decode certificate.txt certificate.p12
-            - run:
-                name: Sync Certs
-                command: |
-                  & $env:SSM\smksp_cert_sync.exe
-            - run:
-                name: Build Installer
-                command: speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss /Sbyparam=$p /DSIGN_INSTALLER /DCODE_SIGNING_CERT_FINGERPRINT=%SM_CODE_SIGNING_CERT_SHA1_HASH%
-                shell: cmd.exe #does not work in powershell
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools/Installers/blender/blender-*.exe
-
-  build-installer-mac:
-    macos:
-      xcode: 13.4.1
-    resource_class: macos.m1.medium.gen1
-    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: Exit if External PR
-          command: if [ "$CIRCLE_PR_REPONAME" ]; then circleci-agent step halt; fi
-      - 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 >>
+      - run: echo "so long and thanks for all the fish"
 
+# Orchestrate our job run sequence
 workflows:
-  build: # build the installers, but don't persist to workspace for deployment
+  build_and_test:
+    when:
+      false
     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: *build_filters
-
-      - build-installer-win:
-          context: digicert-keylocker
-          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:
-              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
-            - 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-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
+      - build

.github/workflows/close-issue.yml

@@ -1,12 +0,0 @@
-name: Update issue Status
-
-on:
-  issues:
-    types: [closed]
-
-jobs:
-  update_issue:
-    uses: specklesystems/github-actions/.github/workflows/project-add-issue.yml@main
-    secrets: inherit
-    with:
-      issue-id: ${{ github.event.issue.node_id }}

.github/workflows/open-issue.yml

@@ -1,12 +0,0 @@
-name: Move new issues into Project
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  track_issue:
-    uses: specklesystems/github-actions/.github/workflows/project-add-issue.yml@main
-    secrets: inherit
-    with:
-      issue-id: ${{ github.event.issue.node_id }}

.github/workflows/pr.yml

@@ -0,0 +1,31 @@
+name: "PR workflow"
+on:
+  pull_request:
+    branches:
+      - "v3-dev"
+jobs:
+  build:
+    name: Pre-commit Checks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.11"
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Install the project
+        run: uv sync --all-extras --dev
+
+      # - uses: actions/cache@v3
+      #   with:
+      #     path: ~/.cache/pre-commit/
+      #     key: ${{ hashFiles('.pre-commit-config.yaml') }}
+
+      # - name: Run pre-commit
+      #   run: uv run pre-commit run --all-files
+
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/release.yml

@@ -0,0 +1,96 @@
+name: "Release workflow"
+on:
+  push:
+    branches: ["main", "installer-test/**"]
+    tags: ["v3.*.*"]
+
+jobs:
+  build:
+    name: Build Zip
+    runs-on: ubuntu-latest
+    env:
+      ZIP_NAME: "blender.zip"
+      SEMVER: null
+      FILE_VERSION: null
+    outputs:
+      semver: ${{ steps.set-version.outputs.semver }}
+      fileVersion: ${{ steps.set-version.outputs.fileVersion }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: 🐍 Install uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.11"
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - id: set-version
+        name: Set version to output
+        run: |
+          TAG=${{ github.ref_name }}
+          if [[ "${{ github.ref }}" != refs/tags/* ]]; then
+            TAG="v3.0.99.${{ github.run_number }}"
+          fi
+          SEMVER="${TAG#v}"
+          FILE_VERSION=$(echo "$TAG" | sed -E 's/^v([0-9]+\.[0-9]+\.[0-9]+).*/\1/')
+          FILE_VERSION="$FILE_VERSION.${{ github.run_number }}"
+
+          echo "semver=$SEMVER" >> "$GITHUB_OUTPUT"
+          echo "fileVersion=$FILE_VERSION" >> "$GITHUB_OUTPUT"
+
+          echo $SEMVER
+          echo $FILE_VERSION
+
+      - name: ✏ Patch Version
+        run: python patch_version.py ${{ steps.set-version.outputs.fileVersion }}
+
+      - name: 🔄 UV Sync
+        run: uv sync --all-extras --dev
+
+      - name: 📄 Export Package Dependencies
+        run: ./export_dependencies.sh
+
+      - name: 🗃 Zip Package
+        run: zip -r ${{env.ZIP_NAME}} bpy_speckle
+
+      - name: ⬆️ Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: output-${{ steps.set-version.outputs.semver }}
+          path: ${{env.ZIP_NAME}}
+          if-no-files-found: error
+          retention-days: 1
+          compression-level: 0 # no compression
+
+      - name: 💾 Minimize uv cache
+        run: uv cache prune --ci
+
+  deploy-installers:
+    runs-on: ubuntu-latest
+    needs: build
+    env:
+      IS_PUBLIC_RELEASE: ${{ github.ref_type == 'tag' }}
+    steps:
+      - name: 🔫 Trigger Build Installer(s)
+        uses: the-actions-org/workflow-dispatch@v4.0.0
+        with:
+          workflow: Build Installers
+          repo: specklesystems/connector-installers
+          token: ${{ secrets.CONNECTORS_GH_TOKEN }}
+          inputs: '{
+            "run_id": "${{ github.run_id }}",
+            "semver": "${{ needs.build.outputs.semver }}",
+            "file_version": "${{ needs.build.outputs.fileVersion }}",
+            "repo": "${{ github.repository }}",
+            "is_public_release": ${{ env.IS_PUBLIC_RELEASE }}
+            }'
+          ref: timestamp-sectigo
+          wait-for-completion: true
+          wait-for-completion-interval: 10s
+          wait-for-completion-timeout: 10m
+          display-workflow-run-url: true
+          display-workflow-run-url-interval: 10s
+
+      - uses: geekyeggo/delete-artifact@v5
+        with:
+          name: output-*

.gitignore

@@ -13,4 +13,5 @@ Installers/
 modules/
 .tool-versions
 requirements.txt
-SEMVER
+SEMVER
+dui3/

README.md

@@ -83,7 +83,7 @@ The full matrix of supported Blender and Speckle types [can be found here](https
 ## Dependency Installation and Compatibility with Other Blender Addons
 
 Upon first launch of the addon, the Speckle connector installs its SpecklePy dependencies in `%appdata%/Speckle/connector_installations` on Windows and `~/.config/Speckle/connector_installations` on Mac.
-This is done through our [`installer.py`](https://github.com/specklesystems/speckle-blender/blob/main/bpy_speckle/installer.py). Through pip, we install the correct version of each dependency for your blender python version, host OS, and system architecture.
+This is done through our [`installer.py`](https://github.com/specklesystems/speckle-blender/blob/main/bpy_speckle/installer.py). Through uv, we install the correct version of each dependency for your blender python version, host OS, and system architecture.
 As such, an internet connection is required for first launch of the connector.
 
 Other blender addons may require dependencies that conflict with specklepy. In these cases, one or both addons may fail to load.

bpy_speckle/__init__.py

@@ -1,113 +1,146 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+# ruff: noqa
 import bpy
-from bpy_speckle.installer import ensure_dependencies
+from bpy.types import WindowManager
+from .connector.ui import icons
+import json
 
+# Ensure dependencies
+from .installer import ensure_dependencies
 ensure_dependencies(f"Blender {bpy.app.version[0]}.{bpy.app.version[1]}")
 
-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",
+    "name": "Speckle Blender ",
     "author": "Speckle Systems",
-    "version": (0, 2, 0),
-    "blender": (2, 92, 0),
+    "version": (3, 999, 999),
+    "blender": (4, 2, 0),
     "location": "3d viewport toolbar (N), under the Speckle tab.",
-    "description": "The Speckle Connector using specklepy 2.0!",
+    "description": "The Speckle Connector using specklepy 3.x!",
     "warning": "This add-on is WIP and should be used with caution",
     "wiki_url": "https://github.com/specklesystems/speckle-blender",
     "category": "Scene",
 }
 
 
+# UI
+from .connector.ui.main_panel import SPECKLE_PT_main_panel
+from .connector.ui.project_selection_dialog import SPECKLE_OT_project_selection_dialog, speckle_project, SPECKLE_UL_projects_list, speckle_workspace
+from .connector.ui.model_selection_dialog import SPECKLE_OT_model_selection_dialog, speckle_model, SPECKLE_UL_models_list
+from .connector.ui.version_selection_dialog import SPECKLE_OT_version_selection_dialog, speckle_version, SPECKLE_UL_versions_list
+from .connector.ui.selection_filter_dialog import SPECKLE_OT_selection_filter_dialog
+from .connector.ui.model_card import speckle_model_card
+# Operators
+from .connector.blender_operators.publish_button import SPECKLE_OT_publish
+from .connector.blender_operators.load_button import SPECKLE_OT_load
+from .connector.blender_operators.model_card_settings import SPECKLE_OT_model_card_settings, SPECKLE_OT_view_in_browser, SPECKLE_OT_view_model_versions, SPECKLE_OT_delete_model_card
+from .connector.blender_operators.select_objects import SPECKLE_OT_select_objects
+from .connector.blender_operators.add_account_button import SPECKLE_OT_add_account
+from .connector.blender_operators.load_latest_button import SPECKLE_OT_load_latest
+from .connector.blender_operators.add_project_by_url import SPECKLE_OT_add_project_by_url
+from .connector.utils.account_manager import speckle_account
+# States
+from .connector.states.speckle_state import register as register_speckle_state, unregister as unregister_speckle_state
 
-"""
-Import SpeckleBlender classes
-"""
-
-"""
-Add load handler to initialize Speckle when 
-loading a Blender file
-"""
-
-@persistent
-def load_handler(dummy):
-    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
-"""
-
-callbacks = {}
-
-"""
-Add Speckle classes for registering
-"""
-
-speckle_classes = []
-speckle_classes.extend(operator_classes)
-speckle_classes.extend(property_classes)
-speckle_classes.extend(ui_classes)
-
-
-def register():
-    from bpy.utils import register_class
-
-    for cls in speckle_classes:
-        register_class(cls)
-
-    metrics.set_host_app("blender", f"blender {bpy.app.version_string}")
-
-    """
-    Register all new properties
-    """
-
-    bpy.types.Scene.speckle = bpy.props.PointerProperty(type=SpeckleSceneSettings)
-    bpy.types.Collection.speckle = bpy.props.PointerProperty(
-        type=SpeckleCollectionSettings
+def invoke_window_manager_properties():
+    # Accounts
+    WindowManager.speckle_accounts = bpy.props.CollectionProperty(
+        type = speckle_account
     )
-    bpy.types.Object.speckle = bpy.props.PointerProperty(type=SpeckleObjectSettings)
+    WindowManager.selected_account_id = bpy.props.StringProperty()
+    # Workspaces
+    WindowManager.speckle_workspaces = bpy.props.CollectionProperty(
+        type = speckle_workspace
+    )
+    WindowManager.selected_workspace_id = bpy.props.StringProperty()
+    # Projects
+    WindowManager.speckle_projects = bpy.props.CollectionProperty(
+                type=speckle_project
+            )
+    WindowManager.selected_project_id = bpy.props.StringProperty()
+    WindowManager.selected_project_name = bpy.props.StringProperty()        
+    # Models
+    WindowManager.speckle_models = bpy.props.CollectionProperty(
+                type=speckle_model
+            )
+    WindowManager.selected_model_id = bpy.props.StringProperty()
+    WindowManager.selected_model_name = bpy.props.StringProperty()
+    # Versions
+    WindowManager.speckle_versions = bpy.props.CollectionProperty(
+            type=speckle_version
+        )
+    WindowManager.selected_version_id = bpy.props.StringProperty()
+    WindowManager.selected_version_load_option = bpy.props.StringProperty()
 
-    """
-    Add callbacks
-    """
+def save_model_cards(scene):
+    model_cards_data = [card.to_dict() for card in scene.speckle_state.model_cards]
+    scene["speckle_model_cards_data"] = json.dumps(model_cards_data)
 
-    # Callback for displaying the current user account on top of the 3d view
-    # callbacks['view3d_status'] = ((
-    #     bpy.types.SpaceView3D.draw_handler_remove, # Function pointer for removal
-    #     bpy.types.SpaceView3D.draw_handler_add(draw_speckle_info, (None, None), 'WINDOW', 'POST_PIXEL'), # Add handler
-    #     'WINDOW' # Callback space for removal
-    #     ))
+def load_model_cards(scene):
+    if "speckle_model_cards_data" in scene:
+        model_cards_data = json.loads(scene["speckle_model_cards_data"])
+        scene.speckle_state.model_cards.clear()
+        for card_data in model_cards_data:
+            card = speckle_model_card.from_dict(card_data)
+            scene.speckle_state.model_cards.add().update(card)
+
+
+# Classes to load
+classes = (
+    SPECKLE_PT_main_panel,
+    SPECKLE_OT_publish,
+    SPECKLE_OT_load,
+    SPECKLE_OT_project_selection_dialog, speckle_project, SPECKLE_UL_projects_list, speckle_workspace,
+    SPECKLE_OT_model_selection_dialog, speckle_model, SPECKLE_UL_models_list,
+    SPECKLE_OT_version_selection_dialog, speckle_version, SPECKLE_UL_versions_list,
+    SPECKLE_OT_selection_filter_dialog,
+    speckle_model_card, SPECKLE_OT_model_card_settings, SPECKLE_OT_view_in_browser, SPECKLE_OT_view_model_versions, SPECKLE_OT_delete_model_card,
+    SPECKLE_OT_select_objects,
+    SPECKLE_OT_add_account,
+    SPECKLE_OT_load_latest,
+    SPECKLE_OT_add_project_by_url,
+    speckle_account)
+
+@bpy.app.handlers.persistent
+def load_handler(dummy):
+    load_model_cards(bpy.context.scene)
+
+@bpy.app.handlers.persistent
+def save_handler(dummy):
+    save_model_cards(bpy.context.scene)
+
+# Register and Unregister
+def register():
+    icons.load_icons()
+
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    register_speckle_state() # Register SpeckleState
 
     bpy.app.handlers.load_post.append(load_handler)
+    bpy.app.handlers.save_post.append(save_handler)
 
+    invoke_window_manager_properties()
 
 def unregister():
+    icons.unload_icons()
+    unregister_speckle_state() # Unregister SpeckleState
+    for cls in classes:
+        bpy.utils.unregister_class(cls)
 
     bpy.app.handlers.load_post.remove(load_handler)
+    bpy.app.handlers.save_post.remove(save_handler)
 
-    """
-    Remove callbacks
-    """
-
-    for cb in callbacks.values():
-        cb[0](cb[1], cb[2])
-
-    from bpy.utils import unregister_class
-
-    for cls in reversed(speckle_classes):
-        unregister_class(cls)
-
-
+# Run the register function when the script is executed
 if __name__ == "__main__":
     register()

bpy_speckle/blender_commit_object_builder.py

@@ -1,120 +0,0 @@
-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 = native_object.users_collection 
-        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:
-            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

bpy_speckle/blender_manifest.toml

@@ -0,0 +1,74 @@
+schema_version = "1.0.0"
+
+# Example of manifest file for a Blender extension
+# Change the values according to your extension
+id = "speckle_blender_addon"
+version = "3.0.0"
+name = "Speckle for Blender BETA"
+tagline = "Speckle connector for Blender"
+maintainer = "AEC SYSTEMS LTD"
+# Supported types: "add-on", "theme"
+type = "add-on"
+
+# Optional link to documentation, support, source files, etc
+website = "https://speckle.guide/user/blender.html"
+
+# Optional list defined by Blender and server, see:
+# https://docs.blender.org/manual/en/dev/advanced/extensions/tags.html
+tags = ["Scene"]
+
+blender_version_min = "4.2.0"
+# # Optional: Blender version that the extension does not support, earlier versions are supported.
+# # This can be omitted and defined later on the extensions platform if an issue is found.
+# blender_version_max = "5.1.0"
+
+# License conforming to https://spdx.org/licenses/ (use "SPDX: prefix)
+# https://docs.blender.org/manual/en/dev/advanced/extensions/licenses.html
+license = [
+  "SPDX:Apache-2.0",
+]
+# Optional: required by some licenses.
+copyright = [
+  "2022-2025 AEC SYSTEMS LTD",
+]
+
+# Optional list of supported platforms. If omitted, the extension will be available in all operating systems.
+# platforms = ["windows-x64", "macos-arm64", "linux-x64"]
+# Other supported platforms: "windows-arm64", "macos-x64"
+
+# Optional: bundle 3rd party Python modules.
+# https://docs.blender.org/manual/en/dev/advanced/extensions/python_wheels.html
+# wheels = [
+#   "./wheels/hexdump-3.3-py3-none-any.whl",
+#   "./wheels/jsmin-3.0.1-py3-none-any.whl",
+# ]
+
+# Optional: add-ons can list which resources they will require:
+# * files (for access of any filesystem operations)
+# * network (for internet access)
+# * clipboard (to read and/or write the system clipboard)
+# * camera (to capture photos and videos)
+# * microphone (to capture audio)
+# permissions = ["files", "network", "clipboard"]
+
+
+# If using network, remember to also check `bpy.app.online_access`
+# https://docs.blender.org/manual/en/dev/advanced/extensions/addons.html#internet-access
+#
+# For each permission it is important to also specify the reason why it is required.
+# Keep this a single short sentence without a period (.) at the end.
+# For longer explanations use the documentation or detail page.
+#
+[permissions]
+network = "Speckle Server comms, and PyPI for dependency management"
+files = "Data caching, Account Management, Python dependency management"
+clipboard = "Copy and paste URLs and Names (UI)"
+
+# Optional: build settings.
+# https://docs.blender.org/manual/en/dev/advanced/extensions/command_line_arguments.html#command-line-args-extension-build
+[build]
+paths_exclude_pattern = [
+  "__pycache__/",
+  "/.vscode",
+  "*.code-workspace",
+]

bpy_speckle/callbacks/__init__.py

@@ -1,2 +0,0 @@
-from .on_mesh_edit import scb_on_mesh_edit
-from .draw_speckle_info import draw_speckle_info

bpy_speckle/callbacks/draw_speckle_info.py

@@ -1,23 +0,0 @@
-"""
-Drawing callback to display active Speckle user
-"""
-
-import blf
-import bpy
-
-
-def draw_speckle_info(self, context):
-    """
-    Draw active user info on the 3d viewport
-    """
-    scn = bpy.context.scene
-    if len(scn.speckle.users) > 0:
-        user = scn.speckle.users[int(scn.speckle.active_user)]
-        dpi = bpy.context.preferences.system.dpi
-
-        blf.position(0, 100, 50, 0)
-        blf.size(0, 20, dpi)
-        blf.draw(0, "Active Speckle user: {} ({})".format(user.name, user.email))
-        blf.position(0, 100, 20, 0)
-        blf.size(0, 16, dpi)
-        blf.draw(0, "Server: {}".format(user.server))

bpy_speckle/callbacks/on_mesh_edit.py

@@ -1,13 +0,0 @@
-import bpy
-from bpy.app.handlers import persistent
-
-
-@persistent
-def scb_on_mesh_edit(context):
-    """
-    DEPRECATED
-    Do something whenever a mesh is updated
-    """
-    edit_obj = bpy.context.edit_object
-    if edit_obj is not None and edit_obj.is_updated_data is True:
-        print("Mesh edited: {}".format(edit_obj))

bpy_speckle/clients.py

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

bpy_speckle/connector/blender_operators/__init__.py

@@ -0,0 +1,9 @@
+from ..blender_operators.load_button import SPECKLE_OT_load # noqa: F401
+from ..blender_operators.load_latest_button import SPECKLE_OT_load_latest # noqa: F401
+from ..blender_operators.publish_button import SPECKLE_OT_publish # noqa: F401
+from ..blender_operators.model_card_settings import (
+    SPECKLE_OT_model_card_settings, #noqa: F401
+    SPECKLE_OT_view_in_browser, #noqa: F401
+    SPECKLE_OT_view_model_versions, #noqa: F401
+    SPECKLE_OT_delete_model_card #noqa: F401
+)

bpy_speckle/connector/blender_operators/add_account_button.py

@@ -0,0 +1,38 @@
+import bpy
+import webbrowser
+from bpy.types import Event, Context
+
+class SPECKLE_OT_add_account(bpy.types.Operator):
+    """Operator for adding a new Speckle account.
+    """
+    bl_idname = "speckle.add_account"
+    bl_label = "Add New Account"
+    bl_description = "Add a new account"
+    
+    server_url: bpy.props.StringProperty(  # type: ignore
+        name="Server URL",
+        description="Speckle server URL to connect to",
+        default="https://app.speckle.systems"
+    )
+    
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        return context.window_manager.invoke_props_dialog(self)
+    
+    def draw(self, context: Context):
+        layout = self.layout
+        # Server URL textbox
+        layout.prop(self, "server_url", text="Server URL")
+    
+    def execute(self, context: Context) -> set[str]:
+        # Logic to handle sign in
+        api_url = "http://localhost:29364"
+        url = f"{api_url}/auth/add-account?serverUrl={self.server_url}"
+        webbrowser.open(url)
+        self.report({'INFO'}, f"Adding account from {self.server_url}: {url}")
+        
+        # Force redraw
+        context.window.screen = context.window.screen
+        context.area.tag_redraw()
+
+            
+        return {'FINISHED'}

bpy_speckle/connector/blender_operators/add_project_by_url.py

@@ -0,0 +1,109 @@
+import bpy
+from bpy.types import Context, Event, UILayout, WindowManager
+from specklepy.api.wrapper import StreamWrapper
+from typing import Tuple
+
+from ...connector.utils.version_manager import get_latest_version
+
+class SPECKLE_OT_add_project_by_url(bpy.types.Operator):
+    """
+    operator for adding a Speckle project by URL
+    """
+
+    bl_idname = "speckle.add_project_by_url"
+    bl_label = "Add Project by URL"
+    bl_description = "Add a project from a URL"
+
+    url: bpy.props.StringProperty(  # type: ignore
+        name="Project URL", description="Enter the Speckle project URL", default=""
+    )
+
+    def execute(self, context: Context) -> set[str]:
+        # TODO: Implement logic to add project using the URL
+        self.report({"INFO"}, f"Adding project from URL: {self.url}")
+
+        wm = context.window_manager
+        try:
+            wrapper = StreamWrapper(self.url)
+        except Exception as e:
+            self.report({"ERROR"}, f"Failed to process URL: {str(e)}")
+            return {"CANCELLED"}
+        # Get model details from the wrapper
+        account_id, project_id, project_name, model_id, model_name, version_id, load_option = get_model_details_by_wrapper(wrapper)
+
+        wm.selected_account_id = account_id
+
+        if project_id:
+            wm.selected_project_id = project_id
+            wm.selected_project_name = project_name
+            if model_id:
+                wm.selected_model_id = model_id
+                wm.selected_model_name = model_name
+                if version_id:
+                    wm.selected_version_id = version_id
+            wm.selected_version_id = version_id
+            wm.selected_version_load_option = load_option
+        context.window.screen = context.window.screen
+        context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        # Ensure all required properties exist in WindowManager
+        if not hasattr(WindowManager, "selected_account_id"):
+            WindowManager.selected_account_id = bpy.props.StringProperty()
+
+        if not hasattr(WindowManager, "selected_project_id"):
+            WindowManager.selected_project_id = bpy.props.StringProperty(
+                name="Selected Project ID"
+            )
+        if not hasattr(WindowManager, "selected_project_name"):
+            WindowManager.selected_project_name = bpy.props.StringProperty(
+                name="Selected Project Name"
+            )
+
+        if not hasattr(WindowManager, "selected_model_id"):
+            WindowManager.selected_model_id = bpy.props.StringProperty(
+                name="Selected Model ID"
+            )
+        if not hasattr(WindowManager, "selected_model_name"):
+            WindowManager.selected_model_name = bpy.props.StringProperty(
+                name="Selected Model Name"
+            )
+
+        if not hasattr(WindowManager, "selected_version_id"):
+            WindowManager.selected_version_id = bpy.props.StringProperty(
+                name="Selected Version ID"
+            )
+
+        if not hasattr(WindowManager, "selected_version_load_option"):
+            WindowManager.selected_version_load_option = bpy.props.StringProperty(
+                name="Selected Version Load Option"
+            )
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.prop(self, "url", text="")
+
+def register() -> None:
+    bpy.utils.register_class(SPECKLE_OT_add_project_by_url)
+
+def unregister() -> None:
+    bpy.utils.unregister_class(SPECKLE_OT_add_project_by_url)
+
+def get_model_details_by_wrapper(wrapper: StreamWrapper) -> Tuple[str, str, str, str, str, str]:
+    client = wrapper.get_client()
+    client.authenticate_with_account(wrapper.get_account())
+    account_id, project_id, project_name, model_id, model_name, version_id, load_option = "", "", "", "", "", "", ""
+    account_id = wrapper.get_account().id
+    if wrapper.stream_id:
+        project_id = wrapper.stream_id
+        project_name = client.project.get(project_id).name
+    if wrapper.model_id:
+        model_id = wrapper.model_id
+        model = client.model.get(model_id, project_id)
+        model_name = model.name
+        load_option = "LATEST" if not wrapper.commit_id else "SPECIFIC"
+        version_id = wrapper.commit_id if wrapper.commit_id else client.version.get_versions(wrapper.model_id, wrapper.stream_id, limit = 1).items[0].id
+    return (account_id, project_id, project_name, model_id, model_name, version_id, load_option)

bpy_speckle/connector/blender_operators/load_button.py

@@ -0,0 +1,42 @@
+import bpy
+from typing import Set
+from bpy.types import Context
+from ..operations.load_operation import load_operation
+from ..utils.account_manager import get_server_url_by_account_id
+
+
+class SPECKLE_OT_load(bpy.types.Operator):
+    bl_idname = "speckle.load"
+    bl_label = "Load from Speckle"
+    bl_description = "Load objects from Speckle"
+
+    def invoke(self, context: Context, event: bpy.types.Event) -> Set[str]:
+        return self.execute(context)
+
+    def execute(self, context: Context) -> Set[str]:
+        wm = context.window_manager
+        model_card = context.scene.speckle_state.model_cards.add()
+        model_card.account_id = wm.selected_account_id
+        model_card.server_url = get_server_url_by_account_id(wm.selected_account_id)
+        model_card.project_id = wm.selected_project_id
+        model_card.project_name = wm.selected_project_name
+        model_card.model_id = wm.selected_model_id
+        model_card.model_name = wm.selected_model_name
+        model_card.is_publish = False
+        model_card.load_option = wm.selected_version_load_option
+        model_card.version_id = wm.selected_version_id
+        model_card.collection_name = f"{wm.selected_model_name} - {wm.selected_version_id[:8]}"
+
+        # Load selected model version
+        load_operation(context)
+
+        # Clear selected model details from Window Manager
+        wm.selected_account_id = ""
+        wm.selected_project_id = ""
+        wm.selected_project_name = ""
+        wm.selected_model_id = ""
+        wm.selected_model_name = ""
+        wm.selected_version_load_option = ""
+        wm.selected_version_id = ""
+
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/load_latest_button.py

@@ -0,0 +1,81 @@
+import bpy
+from typing import Set
+from bpy.types import Context
+from ..utils.version_manager import get_latest_version
+from ..operations.load_operation import load_operation
+
+
+class SPECKLE_OT_load_latest(bpy.types.Operator):
+    bl_idname = "speckle.load_latest"
+    bl_label = "Load Latest from Speckle"
+    bl_description = "Load the latest version from Speckle"
+
+    model_card_id: bpy.props.StringProperty(name="Model Card ID", default="")  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        wm = context.window_manager
+
+        # Get the model card
+        model_card = context.scene.speckle_state.get_model_card_by_id(self.model_card_id)
+
+        # Check if load_option is set to "LATEST"
+        if model_card.load_option != "LATEST":
+            # Do nothing if load_option is not "LATEST"
+            return {"FINISHED"}
+        
+        # Get the latest version from Speckle
+        latest_version_id, message, timestamp = get_latest_version(
+            model_card.account_id, 
+            model_card.project_id, 
+            model_card.model_id
+        )
+        # Throw error if latest version is not found
+        if not latest_version_id:
+            self.report({"ERROR"}, "Failed to get latest version")
+            return {"CANCELLED"}
+        
+        # Check if the collection exists and delete it if it does
+        collection = bpy.data.collections.get(model_card.collection_name)
+        
+        # Update the model card with the latest version ID
+        original_version_id = model_card.version_id
+        if latest_version_id == original_version_id:
+            self.report({"INFO"}, "Latest version is already loaded")
+            return {"FINISHED"}
+
+        if collection:
+            # Remove the collection
+            bpy.data.collections.remove(collection)
+            self.report({"INFO"}, f"Deleted existing collection: {model_card.collection_name}")
+        # overwrite version id of the model card stored in the doc
+        model_card.version_id = latest_version_id
+        
+        # overwrite version id store in wm
+        # Set Window Manager properties 
+        wm.selected_account_id = model_card.account_id
+        wm.selected_project_id = model_card.project_id
+        wm.selected_model_name = model_card.model_name
+        wm.selected_version_id = latest_version_id
+        
+        # Load the latest version
+        try:
+            load_operation(context)
+            self.report(
+                {"INFO"}, 
+                f"Loaded latest version: {latest_version_id[:8]} (was: {original_version_id[:8]})"
+            )
+            # update collection name in model card
+            model_card.collection_name = f"{model_card.model_name} - {latest_version_id[:8]}"
+        except Exception as e:
+            # Restore the original version ID if loading fails
+            model_card.version_id = original_version_id
+            self.report({"ERROR"}, f"Failed to load latest version: {str(e)}")
+            return {"CANCELLED"}
+        
+        # Clear selected model details from Window Manager
+        wm.selected_account_id = ""
+        wm.selected_project_id = ""
+        wm.selected_version_id = ""
+        wm.selected_model_name = ""
+        
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/model_card_settings.py

@@ -0,0 +1,127 @@
+import bpy
+import webbrowser
+from typing import Set
+from bpy.types import Event, Context, UILayout
+
+
+class SPECKLE_OT_model_card_settings(bpy.types.Operator):
+    """
+    manages settings and actions for a Speckle model card
+    """
+
+    bl_idname = "speckle.model_card_settings"
+    bl_label = "Model Card Settings"
+    bl_description = "Settings for the model card"
+    model_card_id: bpy.props.StringProperty(name="Model Card ID", default="")  # type:ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        return {"FINISHED"}
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.operator(
+            "speckle.view_in_browser", text="View in Browser"
+        ).model_card_id = self.model_card_id
+        layout.operator(
+            "speckle.view_model_versions", text="View Model Versions"
+        ).model_card_id = self.model_card_id
+        layout.separator()
+        row = layout.row()
+        # add a button for deleting the model card
+        row.alert = True
+        delete_op = row.operator(
+            "speckle.delete_model_card", text="Delete Model Card", icon="TRASH"
+        )
+        delete_op.model_card_id = self.model_card_id
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        wm = context.window_manager
+        return wm.invoke_popup(self)
+
+
+class SPECKLE_OT_view_in_browser(bpy.types.Operator):
+    """
+    opens the current model in the Speckle web viewer
+    """
+
+    bl_idname = "speckle.view_in_browser"
+    bl_label = "View in Browser"
+    bl_description = "View the model in the browser"
+
+    model_card_id: bpy.props.StringProperty()  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        url = f"{model_card.server_url}/projects/{model_card.project_id}/models/{model_card.model_id}"
+        webbrowser.open(url)
+        self.report({"INFO"}, f"Viewing in the browser: {url}")
+        return {"FINISHED"}
+
+
+class SPECKLE_OT_view_model_versions(bpy.types.Operator):
+    """
+    opens the model's version history in the Speckle web app
+    """
+
+    bl_idname = "speckle.view_model_versions"
+    bl_label = "View Model Versions"
+    bl_description = "View the model versions in the browser"
+
+    model_card_id: bpy.props.StringProperty()  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        url = f"{model_card.server_url}/projects/{model_card.project_id}/models/{model_card.model_id}/versions"
+        webbrowser.open(url)
+
+        self.report({"INFO"}, "Viewing model's versions in the browser")
+        return {"FINISHED"}
+
+
+class SPECKLE_OT_delete_model_card(bpy.types.Operator):
+    """
+    deletes a Speckle model card from the Blender UI
+    """
+
+    bl_idname = "speckle.delete_model_card"
+    bl_label = "Delete Model Card"
+    bl_description = "Delete this model card"
+
+    model_card_id: bpy.props.StringProperty()  # type: ignore
+
+    def execute(self, context: Context) -> Set[str]:
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        model_name = model_card.model_name
+
+        # find the index of the model card and remove it
+        for i, card in enumerate(context.scene.speckle_state.model_cards):
+            if card.get_model_card_id() == self.model_card_id:
+                context.scene.speckle_state.model_cards.remove(i)
+                break
+
+        self.report({"INFO"}, f"Model card '{model_name}' has been deleted")
+        context.window.screen = context.window.screen
+
+        context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        return self.execute(context)

bpy_speckle/connector/blender_operators/publish_button.py

@@ -0,0 +1,20 @@
+import bpy
+from bpy.types import Context
+from bpy.types import Event
+from typing import Set
+
+
+class SPECKLE_OT_publish(bpy.types.Operator):
+    bl_idname = "speckle.publish"
+
+    bl_label = "Publish to Speckle"
+    bl_description = "Publish selected objects to Speckle"
+
+    def invoke(self, context: Context, event: Event) -> Set[str]:
+        return self.execute(context)
+
+    def execute(self, context: Context) -> Set[str]:
+        context.scene.speckle_state.ui_mode = "PUBLISH"
+
+        bpy.ops.speckle.project_selection_dialog("INVOKE_DEFAULT")
+        return {"FINISHED"}

bpy_speckle/connector/blender_operators/select_objects.py

@@ -0,0 +1,53 @@
+import bpy
+from bpy.types import Operator
+from bpy.props import StringProperty
+
+
+class SPECKLE_OT_select_objects(Operator):
+    """
+    select all objects imported from this Speckle model
+    """
+
+    bl_idname = "speckle.select_objects"
+    bl_label = "Select Objects"
+    bl_options = {"REGISTER", "UNDO"}
+
+    model_card_id: StringProperty(
+        name="Model Card ID", description="ID of the model card", default=""
+    )  # type: ignore
+
+    def execute(self, context):
+        model_card = context.scene.speckle_state.get_model_card_by_id(
+            self.model_card_id
+        )
+        if model_card is None:
+            self.report({"ERROR"}, "Model card not found")
+            return {"CANCELLED"}
+
+        collection_name = model_card.collection_name
+
+        collection = bpy.data.collections.get(collection_name)
+        if not collection:
+            self.report({"ERROR"}, f"Collection {collection_name} not found")
+            return {"CANCELLED"}
+
+        # deselect all objects first
+        bpy.ops.object.select_all(action="DESELECT")
+
+        # select all objects in the collection and its child collections
+        def select_collection_objects(collection):
+            for obj in collection.objects:
+                obj.select_set(True)
+            for child in collection.children:
+                select_collection_objects(child)
+
+        select_collection_objects(collection)
+
+        selected = context.selected_objects
+        if selected:
+            context.view_layer.objects.active = selected[0]
+
+            bpy.ops.view3d.view_selected()
+
+        self.report({"INFO"}, f"Selected {len(context.selected_objects)} objects")
+        return {"FINISHED"}

bpy_speckle/connector/operations/__init__.py

@@ -0,0 +1 @@
+from ..operations.load_operation import load_operation  # noqa: F401

bpy_speckle/connector/operations/load_operation.py

@@ -0,0 +1,270 @@
+import bpy
+from bpy.types import Context
+from specklepy.api.credentials import get_local_accounts
+from specklepy.transports.server import ServerTransport
+from specklepy.api import operations
+from specklepy.api.client import SpeckleClient
+from specklepy.objects.models.collections.collection import Collection as SCollection
+from specklepy.objects.graph_traversal.default_traversal import (
+    create_default_traversal_function,
+)
+
+from ..utils.get_ascendants import get_ascendants
+from ...converter.utils import find_object_by_id
+from ...converter.to_native import (
+    convert_to_native,
+    render_material_proxy_to_native,
+    instance_definition_proxy_to_native,
+    find_instance_definitions,
+)
+
+
+def load_operation(context: Context) -> None:
+    """
+    load objects from Speckle and maintain hierarchy.
+    """
+    wm = context.window_manager
+
+    # get account
+    account = next(
+        (
+            acc
+            for acc in get_local_accounts()
+            if acc.id == context.window_manager.selected_account_id
+        ),
+        None,
+    )
+
+    if account is None:
+        print("No Speckle account found")
+        return
+
+    print(f"Using account: {account.userInfo.email}")
+
+    # receive the data
+    client = SpeckleClient(host=account.serverInfo.url)
+    client.authenticate_with_account(account)
+
+    transport = ServerTransport(stream_id=wm.selected_project_id, client=client)
+
+    version = client.version.get(wm.selected_version_id, wm.selected_project_id)
+    obj_id = version.referenced_object
+
+    version_data = operations.receive(obj_id, transport)
+
+    # Create material mapping first
+    material_mapping = render_material_proxy_to_native(version_data)
+
+    definition_collections, definition_objects = instance_definition_proxy_to_native(
+        version_data, material_mapping
+    )
+
+    definitions_root_collection = None
+    if definition_collections:
+        definitions_root_collection = bpy.data.collections.new("InstanceDefinitions")
+
+        for collection in definition_collections.values():
+            definitions_root_collection.children.link(collection)
+
+    definition_object_ids = set()
+    for definition in find_instance_definitions(version_data).values():
+        definition_object_ids.update(definition.objects)
+        for obj_id in definition.objects:
+            found_obj = find_object_by_id(version_data, obj_id)
+            if found_obj:
+                if hasattr(found_obj, "id"):
+                    definition_object_ids.add(found_obj.id)
+                if hasattr(found_obj, "applicationId"):
+                    definition_object_ids.add(found_obj.applicationId)
+
+    traversal_function = create_default_traversal_function()
+
+    root_collection_name = f"{wm.selected_model_name} - {wm.selected_version_id[:8]}"
+    root_collection = bpy.data.collections.new(root_collection_name)
+    context.scene.collection.children.link(root_collection)
+
+    context.window_manager.progress_begin(0, 100)
+
+    converted_objects = definition_objects.copy()
+
+    created_collections = {}
+    created_collections[root_collection_name] = root_collection
+
+    collection_hierarchy = {}
+    all_objects = {}
+
+    speckle_root_id = None
+
+    for traversal_item in traversal_function.traverse(version_data):
+        speckle_obj = traversal_item.current
+
+        # Skip objects that are part of instance definitions
+        if speckle_obj.id in definition_object_ids or (
+            hasattr(speckle_obj, "applicationId")
+            and speckle_obj.applicationId in definition_object_ids
+        ):
+            continue
+
+        all_objects[speckle_obj.id] = speckle_obj
+
+        # get all ascendants in order (current to root)
+        ascendants = list(get_ascendants(traversal_item))
+        parent_ascendants = ascendants[1:] if len(ascendants) > 1 else []
+
+        if isinstance(speckle_obj, SCollection):
+            if not parent_ascendants and speckle_root_id is None:
+                speckle_root_id = speckle_obj.id
+
+            collection_name = getattr(
+                speckle_obj, "name", f"Collection_{speckle_obj.id[:8]}"
+            )
+
+            parent_id = None
+            for parent in parent_ascendants:
+                if isinstance(parent, SCollection) and hasattr(parent, "id"):
+                    parent_id = parent.id
+                    break
+
+            collection_hierarchy[speckle_obj.id] = {
+                "id": speckle_obj.id,
+                "name": collection_name,
+                "parent_id": parent_id,
+                "blender_collection": None,
+                "full_path": [collection_name],
+            }
+
+            if parent_id in collection_hierarchy:
+                collection_hierarchy[speckle_obj.id]["full_path"] = (
+                    collection_hierarchy[parent_id]["full_path"] + [collection_name]
+                )
+
+        else:
+            pass
+
+    def get_collection_depth(coll_id):
+        parent_id = collection_hierarchy[coll_id]["parent_id"]
+        if parent_id is None:
+            return 0
+        if parent_id not in collection_hierarchy:
+            return 0
+        return 1 + get_collection_depth(parent_id)
+
+    sorted_collections = sorted(
+        collection_hierarchy.keys(),
+        key=lambda coll_id: (
+            get_collection_depth(coll_id),
+            collection_hierarchy[coll_id]["name"],
+        ),
+    )
+
+    if speckle_root_id and speckle_root_id in collection_hierarchy:
+        collection_hierarchy[speckle_root_id]["blender_collection"] = root_collection
+        converted_objects[speckle_root_id] = root_collection
+
+    # create collections in depth order (skip the root that's already mapped)
+    for coll_id in sorted_collections:
+        if coll_id == speckle_root_id:
+            continue
+
+        coll_info = collection_hierarchy[coll_id]
+        coll_name = coll_info["name"]
+        parent_id = coll_info["parent_id"]
+        full_path = coll_info["full_path"]
+
+        collection_key = tuple(full_path)
+
+        parent_collection = root_collection
+        if parent_id and parent_id in collection_hierarchy:
+            parent_info = collection_hierarchy[parent_id]
+            if parent_info["blender_collection"]:
+                parent_collection = parent_info["blender_collection"]
+
+        if collection_key in created_collections:
+            print(f"Collection already exists: {coll_name}")
+            blender_collection = created_collections[collection_key]
+        else:
+            blender_collection = bpy.data.collections.new(coll_name)
+            parent_collection.children.link(blender_collection)
+            created_collections[collection_key] = blender_collection
+
+        coll_info["blender_collection"] = blender_collection
+        converted_objects[coll_id] = blender_collection
+
+    conversion_count = 0
+    for traversal_item in traversal_function.traverse(version_data):
+        speckle_obj = traversal_item.current
+
+        if isinstance(speckle_obj, SCollection):
+            continue
+
+        if not hasattr(speckle_obj, "id"):
+            print("Skipping object without ID")
+            continue
+
+        # Skip objects that are part of instance definitions
+        if speckle_obj.id in definition_object_ids or (
+            hasattr(speckle_obj, "applicationId")
+            and speckle_obj.applicationId in definition_object_ids
+        ):
+            continue
+
+        if speckle_obj.id in converted_objects:
+            continue
+
+        try:
+            target_collection = root_collection
+            ascendants = list(get_ascendants(traversal_item))
+
+            for parent in ascendants[1:] if len(ascendants) > 1 else []:
+                if isinstance(parent, SCollection) and hasattr(parent, "id"):
+                    parent_id = parent.id
+                    if parent_id in collection_hierarchy:
+                        coll_info = collection_hierarchy[parent_id]
+                        if coll_info["blender_collection"]:
+                            target_collection = coll_info["blender_collection"]
+                            break
+
+            blender_obj = convert_to_native(
+                speckle_obj,
+                material_mapping,
+                definition_collections=definition_collections,
+                root_collection=target_collection,
+            )
+
+            if blender_obj is None:
+                continue
+
+            converted_objects[speckle_obj.id] = blender_obj
+            if hasattr(speckle_obj, "applicationId"):
+                converted_objects[speckle_obj.applicationId] = blender_obj
+
+            if not isinstance(blender_obj, bpy.types.Collection):
+                try:
+                    already_linked = False
+                    for coll in bpy.data.collections:
+                        if blender_obj.name in coll.objects:
+                            already_linked = True
+
+                    if not already_linked:
+                        target_collection.objects.link(blender_obj)
+
+                except RuntimeError as e:
+                    print(f"Error linking object to collection: {e}")
+
+        except Exception as e:
+            print(f"Error converting {speckle_obj.speckle_type}: {str(e)}")
+            import traceback
+
+            traceback.print_exc()
+
+        conversion_count += 1
+        if conversion_count % 10 == 0:
+            context.window_manager.progress_update(min(conversion_count, 100))
+
+    context.window_manager.progress_end()
+
+    for area in context.screen.areas:
+        if area.type == "OUTLINER":
+            area.tag_redraw()
+
+    print(f"\nLoad process completed. Imported {len(converted_objects)} objects.")

bpy_speckle/connector/states/speckle_state.py

@@ -0,0 +1,32 @@
+import bpy
+from bpy.props import CollectionProperty, StringProperty
+from bpy.types import PropertyGroup
+from typing import Optional
+
+from ..ui.model_card import speckle_model_card
+
+
+class SpeckleState(PropertyGroup):
+    """
+    manages the state of the Speckle addon in Blender
+    """
+
+    ui_mode: StringProperty(name="UI Mode", default="NONE")  # type: ignore
+    model_cards: CollectionProperty(type=speckle_model_card)  # type: ignore
+
+    def get_model_card_by_id(self, model_card_id: str) -> Optional[speckle_model_card]:
+        """Find a model card by its ID."""
+        for model_card in self.model_cards:
+            if model_card.get_model_card_id() == model_card_id:
+                return model_card
+        return None
+
+
+def register() -> None:
+    bpy.utils.register_class(SpeckleState)
+    bpy.types.Scene.speckle_state = bpy.props.PointerProperty(type=SpeckleState)  # type: ignore
+
+
+def unregister() -> None:
+    del bpy.types.Scene.speckle_state
+    bpy.utils.unregister_class(SpeckleState)

bpy_speckle/connector/ui/__init__.py

@@ -0,0 +1 @@
+from .main_panel import SPECKLE_PT_main_panel # noqa: F401

bpy_speckle/connector/ui/icons.py

@@ -0,0 +1,22 @@
+from typing import Optional, Dict
+import os
+import bpy.utils.previews
+
+speckle_icons: Optional[Dict[str, bpy.types.ImagePreview]] = None
+
+def load_icons() -> None:
+    global speckle_icons
+    speckle_icons = bpy.utils.previews.new()
+    icons_dir = os.path.dirname(__file__)
+    speckle_icons.load("speckle_logo", os.path.join(icons_dir, "speckle-logo.png"), 'IMAGE')
+
+def unload_icons() -> None:
+    global speckle_icons
+    if speckle_icons is not None:
+        bpy.utils.previews.remove(speckle_icons)
+
+def get_icon(icon_name: str) -> int:
+    global speckle_icons
+    if speckle_icons is None:
+        raise ValueError("Icons not loaded")
+    return speckle_icons[icon_name].icon_id

bpy_speckle/connector/ui/main_panel.py

@@ -0,0 +1,131 @@
+import bpy
+from bpy.types import UILayout, Context
+from .icons import get_icon
+
+
+class SPECKLE_PT_main_panel(bpy.types.Panel):
+    """
+    main panel for the Speckle addon.
+    """
+
+    bl_label = "Speckle"
+
+    bl_idname = "SPECKLE_PT_main_panel"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "Speckle"
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        layout.label(text="Speckle Connector BETA", icon_value=get_icon("speckle_logo"))
+
+        # check to see if there are any speckle models in the file
+        if not context.scene.speckle_state.model_cards:
+            layout.label(text="Hello!")
+            layout.label(text="There are no Speckle models in this file yet.")
+
+        layout.separator()
+
+        wm = context.window_manager
+        project_selected = bool(getattr(wm, "selected_project_name", None))
+        model_selected = bool(getattr(wm, "selected_model_name", None))
+        version_selected = bool(getattr(wm, "selected_version_id", None))
+
+        # select Project button
+        row = layout.row()
+        project_name = getattr(wm, "selected_project_name", "")
+        project_button_text = project_name if project_selected else "Select Project"
+        project_button_icon = "CHECKMARK" if project_selected else "PLUS"
+        row.operator(
+            "speckle.project_selection_dialog",
+            text=project_button_text,
+            icon=project_button_icon,
+        )
+
+        # select Model button
+        row = layout.row()
+        model_name = getattr(wm, "selected_model_name", "")
+        model_button_text = model_name if model_selected else "Select Model"
+        model_button_icon = "CHECKMARK" if model_selected else "PLUS"
+        row.enabled = project_selected
+        row.operator(
+            "speckle.model_selection_dialog",
+            text=model_button_text,
+            icon=model_button_icon,
+        )
+
+        # select Version button
+        row = layout.row()
+        version_id = getattr(wm, "selected_version_id", "")
+        load_option = getattr(wm, "selected_version_load_option", "")
+        if load_option == "LATEST":
+            version_button_text = "Latest"
+        elif load_option == "SPECIFIC":
+            version_button_text = version_id
+        else:
+            version_button_text = "Select Version"
+
+        version_button_icon = "CHECKMARK" if version_selected else "PLUS"
+        row.enabled = project_selected and model_selected
+        row.operator(
+            "speckle.version_selection_dialog",
+            text=version_button_text,
+            icon=version_button_icon,
+        )
+
+        # load button
+        row = layout.row()
+        row.enabled = project_selected and model_selected and version_selected
+        row.operator("speckle.load", text="Load Model", icon="IMPORT")
+
+        layout.separator()
+
+        # group model cards by project name
+        project_groups = {}
+        for model_card in context.scene.speckle_state.model_cards:
+            project_name = (
+                model_card.project_name if model_card.project_name else "No Project"
+            )
+            if project_name not in project_groups:
+                project_groups[project_name] = []
+            project_groups[project_name].append(model_card)
+
+        for project_name, model_cards in project_groups.items():
+            project_box = layout.box()
+            project_row = project_box.row()
+            project_row.label(text=f"Project: {project_name}", icon="TRIA_RIGHT")
+
+            for model_card in model_cards:
+                box: UILayout = project_box.box()
+                row: UILayout = box.row()
+                icon: str = "EXPORT" if model_card.is_publish else "IMPORT"
+                
+                # Load latest button in the model card
+                row.operator("speckle.load_latest", text="", icon=icon).model_card_id = model_card.get_model_card_id()
+                row.label(text=f"{model_card.model_name}")
+                
+                # Select button in the model card
+                select_op = row.operator(
+                    "speckle.select_objects", text="", icon="RESTRICT_SELECT_OFF"
+                )
+                select_op.model_card_id = model_card.get_model_card_id()
+                
+                # Settings button in the model card
+                row.operator(
+                    "speckle.model_card_settings", text="", icon="PREFERENCES"
+                ).model_card_id = model_card.get_model_card_id()
+                row: UILayout = box.row()
+                if model_card.is_publish:
+                    split: UILayout = row.split(factor=0.33)
+                    # TODO: Connect to selection operator
+                    split.operator("speckle.publish", text="Selection")
+                    split.label(text=f"{model_card.selection_summary}")
+                else:
+                    split: UILayout = row.split(factor=0.33)
+                    # TODO: Connect to version operator
+                    if model_card.load_option == "LATEST":
+                        split.operator("speckle.load", text="Latest")
+                    if model_card.load_option == "SPECIFIC":
+                        split.operator("speckle.load", text=f"{model_card.version_id}")
+                    # TODO: Get last updated time
+                    split.label(text="Last updated: 2 days ago")

bpy_speckle/connector/ui/model_card.py

@@ -0,0 +1,87 @@
+import bpy
+from typing import Dict, Any
+
+
+class speckle_model_card(bpy.types.PropertyGroup):
+    """
+    represents a Speckle model card in the Blender UI
+    """
+
+    account_id: bpy.props.StringProperty(
+        name="Account ID", description="ID of the account", default=""
+    )  # type: ignore
+    server_url: bpy.props.StringProperty(
+        name="Server URL",
+        description="URL of the Server",
+        default="app.speckle.systems",
+    )  # type: ignore
+    project_name: bpy.props.StringProperty(
+        name="Project Name", description="Name of the project", default=""
+    )  # type: ignore
+    project_id: bpy.props.StringProperty(
+        name="Project ID", description="ID of the selected project", default=""
+    )  # type: ignore
+    model_id: bpy.props.StringProperty(
+        name="Model ID", description="ID of the model", default=""
+    )  # type: ignore
+    model_name: bpy.props.StringProperty(
+        name="Model Name", description="Name of the model", default=""
+    )  # type: ignore
+    is_publish: bpy.props.BoolProperty(
+        name="Publish/Load",
+        description="If the model is published or loaded",
+        default=False,
+    )  # type: ignore
+    selection_summary: bpy.props.StringProperty(
+        name="Selection Summary", description="Summary of the selection", default=""
+    )  # type: ignore
+    version_id: bpy.props.StringProperty(
+        name="Version ID", description="ID of the selected version", default=""
+    )  # type: ignore
+    load_option: bpy.props.StringProperty(
+        name="Version ID", description="ID of the selected version", default=""
+    )  # type: ignore
+    collection_name: bpy.props.StringProperty(
+        name="Collection Name", description="Name of the collection", default=""
+    )  # type: ignore
+
+    def get_model_card_id(self) -> str:
+        if not self.project_id or not self.model_id:
+            raise ValueError(
+                "Project ID and Model ID are required to generate a model card ID."
+            )
+        return self.project_id + "-" + self.model_id
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        converts the model card to a dictionary representation
+        """
+        return {
+            "account_id": self.account_id,
+            "server_url": self.server_url,
+            "project_name": self.project_name,
+            "project_id": self.project_id,
+            "model_id": self.model_id,
+            "model_name": self.model_name,
+            "is_publish": self.is_publish,
+            "selection_summary": self.selection_summary,
+            "version_id": self.version_id,
+            "collection_name": self.collection_name,
+        }
+
+    @classmethod
+    def from_dict(cls, data):
+        """
+        creates a new model card instance from a dictionary
+        """
+        item = cls()
+        item.account_id = data["account_id"]
+        item.server_url = data["server_url"]
+        item.project_name = data["project_name"]
+        item.project_id = data["project_id"]
+        item.model_id = data["model_id"]
+        item.model_name = data["model_name"]
+        item.is_publish = data["is_publish"]
+        item.selection_summary = data["selection_summary"]
+        item.version_id = data["version_id"]
+        item.collection_name = data["collection_name"]

bpy_speckle/connector/ui/model_selection_dialog.py

@@ -0,0 +1,137 @@
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event
+from ..utils.model_manager import get_models_for_project
+from ..utils.version_manager import get_latest_version
+
+
+class speckle_model(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing model information
+    """
+
+    name: bpy.props.StringProperty()  # type: ignore
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+    updated: bpy.props.StringProperty(name="Updated")  # type: ignore
+
+
+class SPECKLE_UL_models_list(bpy.types.UIList):
+    """
+    UIList for displaying a list of Speckle models
+    """
+
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        data: PropertyGroup,
+        item: PropertyGroup,
+        icon: str,
+        active_data: PropertyGroup,
+        active_propname: str,
+    ) -> None:
+        if self.layout_type in {"DEFAULT", "COMPACT"}:
+            row = layout.row(align=True)
+            split = row.split(factor=0.5)
+            split.label(text=item.name)
+
+            right_split = split.split(factor=0.25)
+            right_split.label(text=item.id)
+            right_split.label(text=item.updated)
+
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text=item.name)
+
+
+class SPECKLE_OT_model_selection_dialog(bpy.types.Operator):
+    """
+    operator for displaying and handling the model selection dialog
+    """
+
+    bl_idname = "speckle.model_selection_dialog"
+    bl_label = "Select Model"
+
+    def update_models_list(self, context: Context) -> None:
+        wm = context.window_manager
+
+        wm.speckle_models.clear()
+
+        search = self.search_query if self.search_query.strip() else None
+        models = get_models_for_project(
+            wm.selected_account_id, wm.selected_project_id, search=search
+        )
+
+        for name, id, updated in models:
+            model = wm.speckle_models.add()
+            model.name = name
+            model.updated = updated
+            model.id = id
+
+        return None
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search",
+        description="Search a model",
+        default="",
+        update=update_models_list,
+    )
+
+    model_index: bpy.props.IntProperty(name="Model Index", default=0)  # type: ignore
+
+    def execute(self, context: Context) -> set[str]:
+        wm = context.window_manager
+        if 0 <= self.model_index < len(wm.speckle_models):
+            selected_model = wm.speckle_models[self.model_index]
+
+            wm.selected_model_id = selected_model.id
+            wm.selected_model_name = selected_model.name
+
+            latest_version = get_latest_version(
+                account_id=wm.selected_account_id,
+                project_id=wm.selected_project_id,
+                model_id=wm.selected_model_id,
+            )
+            if latest_version:
+                wm.selected_version_load_option = "LATEST"
+                wm.selected_version_id = latest_version[0]
+
+            print(f"Selected model: {selected_model.name} ({selected_model.id})")
+
+            context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        self.update_models_list(context)
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        wm = context.window_manager
+        layout.label(text=f"Project: {wm.selected_project_name}")
+
+        row = layout.row(align=True)
+        row.prop(self, "search_query", icon="VIEWZOOM", text="")
+
+        layout.template_list(
+            "SPECKLE_UL_models_list",
+            "",
+            context.window_manager,
+            "speckle_models",
+            self,
+            "model_index",
+        )
+
+        layout.separator()
+
+
+def register() -> None:
+    bpy.utils.register_class(speckle_model)
+    bpy.utils.register_class(SPECKLE_UL_models_list)
+    bpy.utils.register_class(SPECKLE_OT_model_selection_dialog)
+
+
+def unregister() -> None:
+    bpy.utils.unregister_class(SPECKLE_OT_model_selection_dialog)
+    bpy.utils.unregister_class(SPECKLE_UL_models_list)
+    bpy.utils.unregister_class(speckle_model)

bpy_speckle/connector/ui/project_selection_dialog.py

@@ -0,0 +1,261 @@
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event
+from typing import List, Tuple
+from ..utils.account_manager import get_account_enum_items, speckle_account, get_workspaces, speckle_workspace, get_account_from_id
+from ..utils.project_manager import get_projects_for_account
+
+def get_accounts_callback(self, context):
+    """Callback to dynamically fetch account enum items.
+    """
+    wm = context.window_manager
+    return [
+        (
+            account.id,
+            f"{account.user_name} - {account.user_email} - {account.server_url}",
+            ""
+        )
+        for account in wm.speckle_accounts
+    ]
+
+def get_workspaces_callback(self, context):
+    """
+    Callback to dynamically fetch workspace enum items.
+    """
+    wm = context.window_manager
+    return [
+        (
+            workspace.id,
+            workspace.name,
+            "",
+            "WORKSPACE",
+            i
+        )
+        for i, workspace in enumerate(wm.speckle_workspaces)
+    ]
+
+class speckle_project(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing project information
+    """
+
+    name: bpy.props.StringProperty()  # type: ignore
+    role: bpy.props.StringProperty(name="Role")  # type: ignore
+    updated: bpy.props.StringProperty(name="Updated")  # type: ignore
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+
+
+class SPECKLE_UL_projects_list(bpy.types.UIList):
+    """
+    UIList for displaying a list of Speckle projects
+    """
+
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        data: PropertyGroup,
+        item: PropertyGroup,
+        icon: str,
+        active_data: PropertyGroup,
+        active_propname: str,
+    ) -> None:
+        if self.layout_type in {"DEFAULT", "COMPACT"}:
+            row = layout.row(align=True)
+            split = row.split(factor=0.5)
+            split.label(text=item.name)
+
+            right_split = split.split(factor=0.5)
+            right_split.label(text=item.role)
+            right_split.label(text=item.updated)
+
+        # handles when the list is in a grid layout
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text=item.name)
+
+
+class SPECKLE_OT_project_selection_dialog(bpy.types.Operator):
+    """
+    operator for displaying and handling the project selection dialog
+    """
+
+    bl_idname = "speckle.project_selection_dialog"
+    bl_label = "Select Project"
+
+    def update_workspaces_and_projects_list(self, context: Context) -> None:
+        wm = context.window_manager
+        wm.selected_account_id = self.accounts
+        wm.speckle_workspaces.clear()
+        workspaces = get_workspaces(self.accounts)
+        for id, name in workspaces:
+            workspace: speckle_workspace = wm.speckle_workspaces.add()
+            workspace.id = id
+            workspace.name = name
+        print("Updated Workspaces List!")
+
+        wm.speckle_projects.clear()
+
+        # get projects for the selected account, using search if provided
+        search = self.search_query if self.search_query.strip() else None
+        projects: List[Tuple[str, str, str, str]] = get_projects_for_account(
+            self.accounts, search=search, workspace_id=self.workspaces
+        )
+
+        for name, role, updated, id in projects:
+            project: speckle_project = wm.speckle_projects.add()
+            project.name = name
+            project.role = role
+            project.updated = updated
+            project.id = id
+        print("Updated Projects List!")
+
+        return None
+
+    def update_projects_list(self, context: Context) -> None:
+        """
+        updates the list of projects based on the selected account and search query
+        """
+        wm = context.window_manager
+
+        wm.selected_account_id = self.accounts
+        wm.selected_workspace_id = self.workspaces
+
+        wm.speckle_projects.clear()
+
+        # get projects for the selected account, using search if provided
+        search = self.search_query if self.search_query.strip() else None
+        projects: List[Tuple[str, str, str, str]] = get_projects_for_account(
+            self.accounts, search=search, workspace_id=self.workspaces
+        )
+
+        for name, role, updated, id in projects:
+            project: speckle_project = wm.speckle_projects.add()
+            project.name = name
+            project.role = role
+            project.updated = updated
+            project.id = id
+        print("Updated Projects List!")
+        return None
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search or Paste a URL",
+        description="Search a project or paste a URL to add a project",
+        default="",
+        update=update_projects_list,
+    )
+
+    accounts: bpy.props.EnumProperty(  # type: ignore
+        name="Account",
+        description="Selected account to filter projects by",
+        items=get_accounts_callback,
+        update=update_workspaces_and_projects_list,
+    )
+
+    workspaces: bpy.props.EnumProperty(  # type: ignore
+        name="Workspace",
+        description="Selected workspace to filter projects by",
+        items=get_workspaces_callback,
+        update=update_projects_list
+    )
+    
+    project_index: bpy.props.IntProperty(name="Project Index", default=0)  # type: ignore
+
+    def execute(self, context: Context) -> set[str]:
+        wm = context.window_manager
+        if 0 <= self.project_index < len(wm.speckle_projects):
+            selected_project = wm.speckle_projects[self.project_index]
+
+            wm.selected_project_id = selected_project.id
+            wm.selected_project_name = selected_project.name
+
+            print(f"Selected project: {selected_project.name} ({selected_project.id})")
+
+            context.area.tag_redraw()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        wm = context.window_manager
+
+        # Clear existing accounts and projects
+        wm.speckle_accounts.clear()
+        wm.speckle_projects.clear()
+        wm.speckle_workspaces.clear()
+
+        # Fetch accounts
+        for id, user_name, server_url, user_email in get_account_enum_items():
+            account: speckle_account = wm.speckle_accounts.add()
+            account.id = id
+            account.user_name = user_name
+            account.server_url = server_url
+            account.user_email = user_email
+
+        selected_account_id = self.accounts
+        wm.selected_account_id = selected_account_id
+
+        # Fetch workspaces from server
+        for id, name in get_workspaces(selected_account_id):
+            workspace: speckle_workspace = wm.speckle_workspaces.add()
+            workspace.id = id
+            workspace.name = name
+        selected_workspace_id = self.workspaces
+        wm.selected_workspace_id = selected_workspace_id
+
+        # Fetch projects from server
+        projects: List[Tuple[str, str, str, str]] = get_projects_for_account(
+            selected_account_id, workspace_id=selected_workspace_id
+        )
+
+        for name, role, updated, id in projects:
+            project: speckle_project = wm.speckle_projects.add()
+            project.name = name
+            project.role = role
+            project.updated = updated
+            project.id = id
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        wm = context.window_manager
+        
+        # Account selection
+        row = layout.row()
+        if wm.selected_account_id != "NO_ACCOUNTS":
+            row.prop(self, "accounts", text="")
+        add_account_button_text = "Sign In" if wm.selected_account_id == "NO_ACCOUNTS" else ""
+        add_account_button_icon = 'WORLD' if wm.selected_account_id == "NO_ACCOUNTS" else 'ADD'
+        row.operator("speckle.add_account", icon=add_account_button_icon, text=add_account_button_text)
+        
+        # Workspace selection
+        row = layout.row()
+        if wm.selected_workspace_id != "NO_WORKSPACES":
+            row.prop(self, "workspaces", text="")
+
+        # Search field
+        row = layout.row(align=True)
+        row.prop(self, "search_query", icon="VIEWZOOM", text="")
+        row.operator("speckle.add_project_by_url", icon='LINKED', text="")
+
+        layout.template_list(
+            "SPECKLE_UL_projects_list",
+            "",
+            context.window_manager,
+            "speckle_projects",
+            self,
+            "project_index",
+        )
+        layout.separator()
+
+
+
+def register() -> None:
+    bpy.utils.register_class(speckle_project)
+    bpy.utils.register_class(SPECKLE_UL_projects_list)
+    bpy.utils.register_class(SPECKLE_OT_project_selection_dialog)
+
+
+def unregister() -> None:
+
+    bpy.utils.unregister_class(SPECKLE_OT_project_selection_dialog)
+    bpy.utils.unregister_class(SPECKLE_UL_projects_list)
+    bpy.utils.unregister_class(speckle_project)

bpy_speckle/connector/ui/selection_filter_dialog.py

@@ -0,0 +1,117 @@
+import bpy
+from typing import List
+from bpy.types import Operator, Context, Object
+from bpy.props import EnumProperty, StringProperty
+
+
+class SPECKLE_OT_selection_filter_dialog(Operator):
+    """
+    operator for handling object selection and filtering
+    """
+
+    bl_idname = "speckle.selection_filter_dialog"
+    bl_label = "Select Objects"
+
+    selection_type: EnumProperty(
+        name="Selection",
+        items=[
+            ("SELECTION", "Selection", "Select objects manually"),
+        ],
+        default="SELECTION",
+    )  # type: ignore
+
+    project_name: StringProperty(
+        name="Project Name", description="Name of the selected project", default=""
+    )  # type: ignore
+
+    project_id: StringProperty(
+        name="Project ID", description="ID of the selected project", default=""
+    )  # type: ignore
+
+    model_name: StringProperty(
+        name="Model Name", description="Name of the selected model", default=""
+    )  # type: ignore
+
+    model_id: StringProperty(
+        name="Model ID", description="ID of the selected model", default=""
+    )  # type: ignore
+
+    def execute(self, context: Context) -> set:
+        model_card = context.scene.speckle_state.model_cards.add()
+        model_card.project_name = self.project_name
+        model_card.model_name = self.model_name
+        model_card.model_id = self.model_id
+        model_card.project_id = self.project_id
+        model_card.is_publish = True
+
+        selected_objects: list[Object] = context.selected_objects
+        total_selected: int = len(selected_objects)
+        object_types: dict[str, int] = {}
+        for obj in selected_objects:
+            if obj.type not in object_types:
+                object_types[obj.type] = 1
+            else:
+                object_types[obj.type] += 1
+
+        summary: str = f"{total_selected} objects - "
+        for obj_type, count in object_types.items():
+            summary += f"{obj_type}: {count}, "
+
+        model_card.selection_summary = summary.strip()
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: bpy.types.Event) -> set:
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context):
+        layout = self.layout
+
+        layout.label(text=f"Project: {self.project_name}")
+        layout.label(text=f"Model: {self.model_name}")
+
+        layout.prop(self, "selection_type")
+        layout.separator()
+
+        selected_objects: List[Object] = context.selected_objects
+        total_selected: int = len(selected_objects)
+
+        box = layout.box()
+        row = box.row()
+        row.label(text="Selection Summary", icon="OUTLINER_OB_GROUP_INSTANCE")
+        row.label(text=f"Total: {total_selected}", icon="OBJECT_DATA")
+
+        object_types: dict[str, int] = {}
+        for obj in selected_objects:
+            if obj.type not in object_types:
+                object_types[obj.type] = 1
+            else:
+                object_types[obj.type] += 1
+
+        col = box.column(align=True)
+        for obj_type, count in object_types.items():
+            row = col.row()
+            row.label(text=f"{obj_type}:", icon=self.get_icon_for_type(obj_type))
+            row.label(text=str(count))
+
+        layout.separator()
+
+    def get_icon_for_type(self, obj_type: str) -> str:
+        icon_map: dict[str, str] = {
+            "MESH": "OUTLINER_OB_MESH",
+            "CURVE": "OUTLINER_OB_CURVE",
+            "SURFACE": "OUTLINER_OB_SURFACE",
+            "META": "OUTLINER_OB_META",
+            "FONT": "OUTLINER_OB_FONT",
+            "ARMATURE": "OUTLINER_OB_ARMATURE",
+            "LATTICE": "OUTLINER_OB_LATTICE",
+            "EMPTY": "OUTLINER_OB_EMPTY",
+            "GPENCIL": "OUTLINER_OB_GREASEPENCIL",
+            "CAMERA": "OUTLINER_OB_CAMERA",
+            "LIGHT": "OUTLINER_OB_LIGHT",
+            "SPEAKER": "OUTLINER_OB_SPEAKER",
+            "LIGHT_PROBE": "OUTLINER_OB_LIGHTPROBE",
+        }
+        return icon_map.get(obj_type, "OBJECT_DATA")
+
+    def check(self, context: Context) -> bool:
+        return True  # this forces the dialog to redraw

bpy_speckle/connector/ui/version_selection_dialog.py

@@ -0,0 +1,153 @@
+import bpy
+from bpy.types import UILayout, Context, PropertyGroup, Event
+from ..utils.version_manager import get_versions_for_model, get_latest_version
+
+
+class speckle_version(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing version information
+    """
+
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+    message: bpy.props.StringProperty(name="Message")  # type: ignore
+    updated: bpy.props.StringProperty(name="Updated")  # type: ignore
+    source_app: bpy.props.StringProperty(name="Source")  # type: ignore
+
+
+class SPECKLE_UL_versions_list(bpy.types.UIList):
+    """
+    UIList for displaying a list of Speckle versions
+    """
+
+    # TODO: Adjust column widths so message has the most space.
+    def draw_item(
+        self,
+        context: Context,
+        layout: UILayout,
+        data: PropertyGroup,
+        item: PropertyGroup,
+        icon: str,
+        active_data: PropertyGroup,
+        active_propname: str,
+    ) -> None:
+        if self.layout_type in {"DEFAULT", "COMPACT"}:
+            row = layout.row(align=True)
+            split = row.split(factor=0.166)
+            split.label(text=item.id)
+            right_split = split.split(factor=0.7)
+            right_split.label(text=item.message)
+            right_split.label(text=item.updated)
+
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text=item.id)
+
+
+class SPECKLE_OT_version_selection_dialog(bpy.types.Operator):
+    bl_idname = "speckle.version_selection_dialog"
+    bl_label = "Select Version"
+
+    search_query: bpy.props.StringProperty(  # type: ignore
+        name="Search", description="Search a project", default=""
+    )
+
+    version_index: bpy.props.IntProperty(name="Model Index", default=0)  # type: ignore
+
+    load_option: bpy.props.EnumProperty(  # type: ignore
+        name="Load Option",
+        description="Choose how to load the version",
+        items=[
+            ("LATEST", "Load latest version", "Load the latest version available"),
+            (
+                "SPECIFIC",
+                "Load a specific version",
+                "Load a specific version from the list",
+            ),
+        ],
+        default="LATEST",
+    )
+
+    def update_versions_list(self, context: Context) -> None:
+        wm = context.window_manager
+        wm.speckle_versions.clear()
+
+        search = self.search_query if self.search_query.strip() else None
+        versions = get_versions_for_model(
+            account_id=wm.selected_account_id,
+            project_id=wm.selected_project_id,
+            model_id=wm.selected_model_id,
+            search=search,
+        )
+
+        for id, message, updated in versions:
+            version = wm.speckle_versions.add()
+            version.id = id
+            version.message = message
+            version.updated = updated
+
+        return None
+
+    def execute(self, context: Context) -> set[str]:
+        wm = context.window_manager
+
+        version_id_to_store = ""
+
+        if self.load_option == "LATEST":
+            latest_version = get_latest_version(
+                account_id=wm.selected_account_id,
+                project_id=wm.selected_project_id,
+                model_id=wm.selected_model_id,
+            )
+            if latest_version:
+                version_id_to_store = latest_version[0]
+            else:
+                print(
+                    f"Could not fetch latest version for model {wm.selected_model_id}"
+                )
+                return {"CANCELLED"}
+
+        elif self.load_option == "SPECIFIC":
+            if 0 <= self.version_index < len(wm.speckle_versions):
+                selected_version = wm.speckle_versions[self.version_index]
+                version_id_to_store = selected_version.id
+            else:
+                print(f"Invalid version index {self.version_index}")
+                return {"CANCELLED"}
+
+        wm.selected_version_id = version_id_to_store
+        wm.selected_version_load_option = self.load_option
+
+        print(f"Selected version: {version_id_to_store} (Option: {self.load_option})")
+
+        context.area.tag_redraw()
+
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        self.update_versions_list(context)
+
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context: Context) -> None:
+        layout: UILayout = self.layout
+        wm = context.window_manager
+        layout.label(text=f"Project: {wm.selected_project_name}")
+        layout.label(text=f"Model: {wm.selected_model_name}")
+
+        layout.prop(self, "load_option", expand=True)
+
+        if self.load_option == "SPECIFIC":
+            # Search field
+            row = layout.row(align=True)
+            row.prop(self, "search_query", icon="VIEWZOOM", text="")
+            # Versions UIList
+            layout.template_list(
+                "SPECKLE_UL_versions_list",
+                "",
+                context.window_manager,
+                "speckle_versions",
+                self,
+                "version_index",
+            )
+
+        layout.separator()

bpy_speckle/connector/utils/account_manager.py

@@ -0,0 +1,125 @@
+import bpy
+from specklepy.api.credentials import get_local_accounts
+from typing import List, Tuple, Optional
+from specklepy.core.api.credentials import Account
+from specklepy.api.client import SpeckleClient
+from .misc import strip_non_ascii
+
+
+class speckle_account(bpy.types.PropertyGroup):
+    id: bpy.props.StringProperty()  # type: ignore
+    user_name: bpy.props.StringProperty()  # type: ignore
+    server_url: bpy.props.StringProperty()  # type: ignore
+    user_email: bpy.props.StringProperty()  # type: ignore
+
+
+class speckle_workspace(bpy.types.PropertyGroup):
+    """
+    PropertyGroup for storing workspace information
+    """
+
+    id: bpy.props.StringProperty(name="ID")  # type: ignore
+    name: bpy.props.StringProperty()  # type: ignore
+
+
+def get_account_enum_items() -> List[Tuple[str, str, str, str]]:
+    accounts: List[Account] = get_local_accounts()
+    if not accounts:
+        print("No accounts found!")
+        return [("NO_ACCOUNTS", "No accounts found!", "", "")]
+    print("Accounts added")
+    speckle_accounts = []
+    for acc in accounts:
+        speckle_accounts.append(
+            (
+                acc.id,
+                strip_non_ascii(acc.userInfo.name),
+                acc.serverInfo.url,
+                acc.userInfo.email,
+            )
+        )
+    return speckle_accounts
+
+
+def get_workspaces(account_id: str) -> List[Tuple[str, str]]:
+    """
+    retrieves the workspaces for a given account ID
+    """
+    account = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+    client = SpeckleClient(host=account.serverInfo.url)
+    client.authenticate_with_account(account)
+    workspaces_enabled = client.server.get().workspaces.workspaces_enabled
+
+    if workspaces_enabled:
+        workspaces = client.active_user.get_workspaces().items
+        workspace_list = [
+            (ws.id, strip_non_ascii(ws.name))
+            for ws in workspaces
+            if ws.creation_state == None or ws.creation_state.completed
+        ]
+        personal_projects_text = "Personal Projects (Legacy)"
+    else:
+        workspace_list = []
+        personal_projects_text = "Personal Projects"
+    # Append Personal Projects do workspace dropdown
+    if client.active_user.can_create_personal_projects().authorized:
+        workspace_list.append(("personal", personal_projects_text))
+
+    print("Workspaces added")
+    return (
+        reorder_tuple(workspace_list, get_default_workspace_id(account_id))
+        if workspaces_enabled
+        else workspace_list
+    )
+
+
+def get_default_account_id() -> Optional[str]:
+    """
+    retrieves the ID of the default Speckle account
+    """
+    return next(
+        (acc.id for acc in get_local_accounts() if acc.isDefault), "NO_ACCOUNTS"
+    )
+
+
+def get_server_url_by_account_id(account_id: str) -> Optional[str]:
+    """
+    retrieves the server URL for a given account ID
+    """
+    accounts: List[Account] = get_local_accounts()
+    for acc in accounts:
+        if acc.id == account_id:
+            return acc.serverInfo.url
+    return None
+
+
+def get_default_workspace_id(account_id: str) -> Optional[str]:
+    """
+    retrieves the ID of the default workspace for a given account ID
+    """
+    account = next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+    client = SpeckleClient(host=account.serverInfo.url)
+    client.authenticate_with_account(account)
+    return (
+        client.active_user.get_active_workspace().id
+        if client.active_user.get_active_workspace()
+        else "personal"
+    )
+
+
+def get_account_from_id(account_id: str) -> Optional[Account]:
+    return next((acc for acc in get_local_accounts() if acc.id == account_id), None)
+
+
+def reorder_tuple(tuple_list, target_id):
+    for i, (id, value) in enumerate(tuple_list):
+        if id == target_id:
+            # Remove the tuple from its current position
+            target_tuple = tuple_list.pop(i)
+            # Insert it at the beginning of the list
+            tuple_list.insert(0, target_tuple)
+            return tuple_list
+
+    # If the target_id wasn't found
+    print(f"Tuple with ID {target_id} not found in the list")
+    return tuple_list

bpy_speckle/connector/utils/get_ascendants.py

@@ -0,0 +1,26 @@
+from typing import Iterator, TypeVar, Type
+from specklepy.objects.base import Base
+from specklepy.objects.graph_traversal.traversal import TraversalContext
+
+
+def get_ascendants(context: TraversalContext) -> Iterator[Base]:
+    """
+    walks up the tree, returning all ascendants, including context
+    """
+    head = context
+    while head is not None:
+        yield head.current
+        head = head.parent
+
+
+T = TypeVar("T", bound=Base)
+
+
+def get_ascendant_of_type(context: TraversalContext, type_cls: Type[T]) -> Iterator[T]:
+    """
+    walks up the tree, returning all ascendants of the given type,
+    starting with the context, walking up parent nodes
+    """
+    for ascendant in get_ascendants(context):
+        if isinstance(ascendant, type_cls):
+            yield ascendant

bpy_speckle/connector/utils/misc.py

@@ -0,0 +1,51 @@
+from datetime import datetime, timezone
+import re
+
+def format_relative_time(timestamp) -> str:
+    """
+    convert UTC timestamp to local timezone and return relative time string
+    """
+    if not timestamp:
+        return "Unknown"
+
+    # convert to local timezone
+    try:
+        try:
+            dt = datetime.fromisoformat(str(timestamp).replace("Z", "+00:00"))
+        except ValueError:
+            try:
+                ts = float(timestamp)
+                dt = datetime.fromtimestamp(ts / 1000, tz=timezone.utc)
+            except (ValueError, TypeError):
+                return "Invalid timestamp"
+
+        local_dt = dt.astimezone()
+
+        # calculate relative time
+        now = datetime.now(timezone.utc).astimezone()
+        delta = now - local_dt
+
+        if delta.days == 0:
+            if delta.seconds < 3600:
+                minutes = delta.seconds // 60
+                return f"{minutes} minutes ago"
+            else:
+                hours = delta.seconds // 3600
+                return f"{hours} hours ago"
+        else:
+            return f"{delta.days} days ago"
+    except ValueError:
+        return "Invalid timestamp"
+
+
+def format_role(role: str) -> str:
+    """
+    This function takes a Speckle role string in the format "prefix:role" and
+    returns just the role part
+    """
+    split_role = role.split(":")
+    return f"{split_role[1]}"
+
+def strip_non_ascii(text):
+    # Keep English letters, digits, spaces and basic punctuation
+    return re.sub(r'[^a-zA-Z0-9\s.,!?]', '', text)

bpy_speckle/connector/utils/model_manager.py

@@ -0,0 +1,52 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import get_local_accounts, Account
+from specklepy.core.api.inputs.project_inputs import ProjectModelsFilter
+from specklepy.core.api.models.current import Model
+from typing import List, Tuple, Optional
+from .misc import format_relative_time, strip_non_ascii
+
+
+def get_models_for_project(
+    account_id: str, project_id: str, search: Optional[str] = None
+) -> List[Tuple[str, str, str]]:
+    """
+    fetches models for a given project from the Speckle server
+    """
+    try:
+        if not account_id or not project_id:
+            print(
+                f"Error: Invalid inputs - account_id: {account_id}, project_id: {project_id}"
+            )
+            return []
+
+        # Get the account info
+        account: Optional[Account] = next(
+            (acc for acc in get_local_accounts() if acc.id == account_id), None
+        )
+        if not account:
+            print(f"Error: Could not find account with ID: {account_id}")
+            return []
+
+        client = SpeckleClient(host=account.serverInfo.url)
+        client.authenticate_with_account(account)
+
+        try:
+            client.project.get(project_id)
+        except Exception as e:
+            print(f"Error: Project with ID {project_id} not found: {str(e)}")
+            return []
+
+        filter = ProjectModelsFilter(search=search) if search else None
+
+        models: List[Model] = client.model.get_models(
+            project_id=project_id, models_limit=10, models_filter=filter
+        ).items
+
+        return [
+            (strip_non_ascii(model.name), model.id, format_relative_time(model.updated_at))
+            for model in models
+        ]
+
+    except Exception as e:
+        print(f"Error fetching models: {str(e)}")
+        return []

bpy_speckle/connector/utils/project_manager.py

@@ -0,0 +1,48 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import get_local_accounts
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter
+from typing import List, Tuple, Optional
+from specklepy.core.api.credentials import Account
+from .misc import format_relative_time, format_role, strip_non_ascii
+
+def get_projects_for_account(
+    account_id: str, workspace_id: str = None, search: Optional[str] = None
+) -> List[Tuple[str, str, str, str]]:
+    """
+    fetches projects for a given account from the Speckle server
+    """
+    try:
+        # Get the account info
+        accounts: List[Account] = get_local_accounts()
+        account: Optional[Account] = next(
+            (acc for acc in accounts if acc.id == account_id), None
+        )
+        if not account:
+            return []
+
+        client = SpeckleClient(host=account.serverInfo.url)
+        client.authenticate_with_account(account)
+
+        personal_only = workspace_id == "personal"
+        workspace_id = None if personal_only else workspace_id
+        filter = UserProjectsFilter(search=search, workspaceId=workspace_id, personalOnly=personal_only)
+
+        projects = client.active_user.get_projects(limit=10, filter=filter).items
+
+        return [
+            (
+                strip_non_ascii(project.name),
+                format_role(project.role),
+                format_relative_time(project.updated_at),
+                project.id,
+            )
+            for project in projects
+        ]
+
+    except Exception as e:
+        import traceback
+
+        error_msg = f"Error: {str(e)}\n"
+        error_msg += f"Traceback:\n{''.join(traceback.format_tb(e.__traceback__))}"
+        print(error_msg)
+        return []

bpy_speckle/connector/utils/version_manager.py

@@ -0,0 +1,99 @@
+from specklepy.api.client import SpeckleClient
+from specklepy.api.credentials import get_local_accounts, Account
+from typing import List, Tuple, Optional
+from .misc import format_relative_time, strip_non_ascii
+from specklepy.core.api.inputs.model_inputs import ModelVersionsFilter
+from specklepy.core.api.models.current import Version
+
+
+def get_versions_for_model(
+    account_id: str, project_id: str, model_id: str, search: Optional[str] = None
+) -> List[Tuple[str, str, str]]:
+    """
+    fetches versions for a given model from the Speckle server
+    """
+    try:
+        # Validate inputs
+        if not account_id or not project_id or not model_id:
+            print(
+                f"Error: Invalid inputs - account_id: {account_id}, project_id: {project_id}, model_id: {model_id}"
+            )
+            return []
+
+        # Get the account info
+        account: Optional[Account] = next(
+            (acc for acc in get_local_accounts() if acc.id == account_id), None
+        )
+        if not account:
+            print(f"Error: Could not find account with ID: {account_id}")
+            return []
+
+        # Initialize the client
+        client: SpeckleClient = SpeckleClient(host=account.serverInfo.url)
+        # Authenticate
+        client.authenticate_with_account(account)
+
+        filter: ModelVersionsFilter = ModelVersionsFilter(search=search, priorityIds=[])
+
+        # Get versions
+        versions: List[Version] = client.version.get_versions(
+            project_id=project_id, model_id=model_id, limit=10, filter=filter
+        )
+
+        return [
+            (
+                version.id,
+                strip_non_ascii(version.message) or "No message",
+                format_relative_time(version.created_at),
+            )
+            for version in versions if not version.referenced_object
+        ]
+
+    except Exception as e:
+        print(f"Error fetching versions: {str(e)}")
+        return []
+
+
+def get_latest_version(
+    account_id: str, project_id: str, model_id: str
+) -> Tuple[str, str, str]:
+    try:
+        # Validate inputs
+        if not account_id or not project_id or not model_id:
+            print(
+                f"Error: Invalid inputs - account_id: {account_id}, project_id: {project_id}, model_id: {model_id}"
+            )
+            return ("", "", "")
+
+        # Get the account info
+        account: Optional[Account] = next(
+            (acc for acc in get_local_accounts() if acc.id == account_id), None
+        )
+        if not account:
+            print(f"Error: Could not find account with ID: {account_id}")
+            return ("", "", "")
+
+        # Initialize the client
+        client: SpeckleClient = SpeckleClient(host=account.serverInfo.url)
+        # Authenticate
+        client.authenticate_with_account(account)
+
+        # Get versions (limit to 1 since we only need the latest)
+        versions: List[Version] = client.version.get_versions(
+            project_id=project_id, model_id=model_id, limit=1
+        ).items
+
+        if not versions:
+            print(f"Error: No versions found for model_id: {model_id}")
+            return ("", "", "")
+
+        latest = versions[0]
+        return (
+            latest.id,
+            strip_non_ascii(latest.message) or "No message",
+            format_relative_time(latest.created_at),
+        )
+
+    except Exception as e:
+        print(f"Error fetching latest version: {str(e)}")
+        return ("", "", "")

bpy_speckle/convert/constants.py

@@ -1,22 +0,0 @@
-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 = '.'

bpy_speckle/convert/to_native.py

@@ -1,817 +0,0 @@
-import math
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Union, Collection, cast
-from bpy_speckle.convert.constants import DISPLAY_VALUE_PROPERTY_ALIASES, ELEMENTS_PROPERTY_ALIASES, OBJECT_NAME_MAX_LENGTH, OBJECT_NAME_NUMERAL_SEPARATOR, OBJECT_NAME_SPECKLE_SEPARATOR, SPECKLE_ID_LENGTH
-from bpy_speckle.functions import get_default_traversal_func, get_scale_length, _report
-from bpy_speckle.convert.util import ConversionSkippedException
-from mathutils import (
-    Matrix as MMatrix,
-    Vector as MVector,
-    Quaternion as MQuaternion,
-)
-import bpy, bmesh
-from specklepy.objects.other import (
-    Collection as SCollection,
-    Instance,
-    Transform,
-    BlockDefinition,
-)
-from specklepy.objects.base import Base
-from specklepy.objects.geometry import Mesh, Line, Polyline, Curve, Arc, Polycurve, Ellipse, Circle, Plane
-from bpy.types import Object, Collection as BCollection
-
-from .util import (
-    add_to_hierarchy,
-    get_render_material,
-    get_vertex_color_material,
-    render_material_to_native,
-    add_custom_properties,
-    add_vertices,
-    add_faces,
-    add_colors,
-    add_uv_coords,
-)
-
-SUPPORTED_CURVES = (Line, Polyline, Curve, Arc, Polycurve, Ellipse, Circle)
-CAN_CONVERT_TO_NATIVE = (
-
-    Mesh,
-    *SUPPORTED_CURVES,
-    Instance,
-)
-
-
-def _has_native_conversion(speckle_object: Base) -> bool: 
-    return any(isinstance(speckle_object, t) for t in CAN_CONVERT_TO_NATIVE) or "View" in speckle_object.speckle_type #hack
-
-def _has_fallback_conversion(speckle_object: Base) -> bool: 
-    return any(getattr(speckle_object, alias, None) for alias in DISPLAY_VALUE_PROPERTY_ALIASES)
-
-def can_convert_to_native(speckle_object: Base) -> bool:
-
-    if(_has_native_conversion(speckle_object) or _has_fallback_conversion(speckle_object)):
-        return True
-    return False
-
-convert_instances_as: str = "" #HACK: This is hacky, we need a better way to pass settings down to the converter
-def set_convert_instances_as(value: str):
-    global convert_instances_as
-    convert_instances_as = value
-    
-    #TODO: Check usages handle exceptions
-
-def convert_to_native(speckle_object: Base) -> Object:
-
-    speckle_type = type(speckle_object)
-
-    object_name = _generate_object_name(speckle_object)
-    scale = get_scale_factor(speckle_object)
-
-    converted: Union[bpy.types.ID, bpy.types.Object, None] = None
-    children: list[Object] = []
-
-    # convert elements/breps
-    if not _has_native_conversion(speckle_object):
-        (converted, children) = display_value_to_native(speckle_object, object_name, scale)
-        if not converted and not children:
-            raise Exception(f"Zero geometry converted from displayValues for {speckle_object}")
-
-    # convert supported geometry
-    elif isinstance(speckle_object, Mesh):
-        converted = mesh_to_native(speckle_object, object_name, scale)
-    elif speckle_type in SUPPORTED_CURVES:
-        converted = icurve_to_native(speckle_object, object_name, scale)
-    elif "View" in speckle_object.speckle_type:
-         return view_to_native(speckle_object, object_name, scale)
-    elif isinstance(speckle_object, Instance):
-        if convert_instances_as == "linked_duplicates":
-           converted = instance_to_native_object(speckle_object, scale)
-        elif convert_instances_as == "collection_instance":
-            converted = instance_to_native_collection_instance(speckle_object, scale)
-        else:
-            _report(f"convert_instances_as = '{convert_instances_as}' is not implemented, Instances will be converted as collection instances!")
-            converted = instance_to_native_collection_instance(speckle_object, scale)
-    else:
-        raise Exception(f"Unsupported type {speckle_type}")
-
-
-    if not isinstance(converted, Object):
-        converted = create_new_object(converted, object_name)
-    
-    converted.speckle.object_id = str(speckle_object.id) # type: ignore
-    converted.speckle.enabled = True # type: ignore
-    add_custom_properties(speckle_object, converted)
-
-    for c in children:
-        c.parent = converted
-
-    return converted
-
-
-
-def display_value_to_native(speckle_object: Base, name: str, scale: float) -> tuple[Optional[bpy.types.Mesh], list[bpy.types.Object]]:
-    return _members_to_native(speckle_object, name, scale, DISPLAY_VALUE_PROPERTY_ALIASES, True)
-
-def elements_to_native(speckle_object: Base, name: str, scale: float) -> list[bpy.types.Object]:
-    (_, elements) = _members_to_native(speckle_object, name, scale, ELEMENTS_PROPERTY_ALIASES, False)
-    return elements
-
-def _members_to_native(speckle_object: Base, name: str, scale: float, members: Iterable[str], combineMeshes: bool) -> tuple[Optional[bpy.types.Mesh], list[bpy.types.Object]]:
-    """
-    Converts a given speckle_object by converting specified members
-
-    if combineMeshes == True
-        Converts mesh members as one mesh
-        Converts non-mesh members as child Objects
-    if combineMeshes == False
-        Converts all members as child objects (first item of the returned tuple will be None)
-    :returns: converted mesh, and any other converted child objects (may happen if members contained non-meshes)
-    """
-    meshes: list[Mesh] = []
-    others: list[Base] = []
-
-    for alias in members:
-        display = getattr(speckle_object, alias, None)
-
-        count = 0
-        MAX_DEPTH = 255 # some large value, to prevent infinite recursion
-        def separate(value: Any) -> bool:
-            nonlocal meshes, others, count, MAX_DEPTH
-
-            if combineMeshes and isinstance(value, Mesh):
-                meshes.append(value)
-            elif isinstance(value, Base):
-                others.append(value)
-            elif isinstance(value, list):
-                count += 1
-                if(count > MAX_DEPTH):
-                    return True
-                for x in value:
-                    separate(x) 
-
-            return False
-
-        did_halt = separate(display)
-
-        if did_halt:
-            _report(f"Traversal of {speckle_object.speckle_type} {speckle_object.id} halted after traversal depth exceeds MAX_DEPTH={MAX_DEPTH}. Are there circular references object structure?")
-
-
-    children: list[Object] = []
-    mesh = None
-
-    if meshes:
-        mesh = meshes_to_native(speckle_object, meshes, name, scale) #TODO: reconsider passing scale around...
-
-    for item in others:
-        try:
-            blender_object = convert_to_native(item)
-            children.append(blender_object)
-        except Exception as ex:
-            _report(f"Failed to convert display value {item}: {ex}")
-
-    return (mesh, children)
-
-
-
-def view_to_native(speckle_view, name: str, scale: float) -> bpy.types.Object:
-    native_cam: bpy.types.Camera
-    if name in bpy.data.cameras.keys():
-         native_cam = bpy.data.cameras[name]
-    else:
-        native_cam = bpy.data.cameras.new(name=name)
-        native_cam.lens = 18 # 90° horizontal fov
-
-    if not hasattr(speckle_view, "origin"):
-        raise ConversionSkippedException("2D views not supported")
-
-    cam_obj = create_new_object(native_cam, name)
-
-    scale_factor = get_scale_factor(speckle_view, scale)
-    tx = (speckle_view.origin.x * scale_factor)
-    ty = (speckle_view.origin.y * scale_factor)
-    tz = (speckle_view.origin.z * scale_factor)
-
-    forward = MVector((speckle_view.forwardDirection.x, speckle_view.forwardDirection.y, speckle_view.forwardDirection.z))
-    up = MVector((speckle_view.upDirection.x, speckle_view.upDirection.y, speckle_view.upDirection.z))
-    right = forward.cross(up).normalized()
-
-    cam_obj.matrix_world = MMatrix((
-        (right.x,  up.x,  -forward.x, tx),
-        (right.y,  up.y,  -forward.y, ty),
-        (right.z,  up.z,  -forward.z, tz),
-        (0,          0,     0,       1 )
-    ))
-    return cam_obj
-
-def mesh_to_native(speckle_mesh: Mesh, name: str, scale: float) -> bpy.types.Mesh:
-    return meshes_to_native(speckle_mesh, [speckle_mesh], name, scale)
-
-
-
-def meshes_to_native(element: Base, meshes: Collection[Mesh], name: str, scale: float) -> bpy.types.Mesh:
-    if name in bpy.data.meshes.keys():
-        return bpy.data.meshes[name]
-    blender_mesh = bpy.data.meshes.new(name=name)
-
-    fallback_material = get_render_material(element)
-
-    bm = bmesh.new()
-
-    # First pass, add vertex data
-    for mesh in meshes:
-        scale = get_scale_factor(mesh, scale)
-        add_vertices(mesh, bm, scale)
-
-    bm.verts.ensure_lookup_table()
-
-    # Second pass, add face data
-    offset = 0
-    for i, mesh in enumerate(meshes):
-        if not mesh.vertices: continue
-
-        add_faces(mesh, bm, offset, i)
-
-        try:
-            render_material = get_render_material(mesh) or fallback_material
-            if render_material is not None:
-                native_material = render_material_to_native(render_material)
-                blender_mesh.materials.append(native_material)
-            elif mesh.colors:
-                native_material = get_vertex_color_material()
-                blender_mesh.materials.append(native_material)
-        except Exception as ex:
-            _report(f"Failed converting render material for {name}: {ex}")
-
-        offset += len(mesh.vertices) // 3
-
-    bm.faces.ensure_lookup_table()
-    bm.verts.index_update()
-
-    # Third pass, add vertex instance data
-    for mesh in meshes:
-        try:
-            add_colors(mesh, bm)
-        except Exception as ex:
-            _report(f"Skipping converting vertex colors for {name}: {ex}")
-            
-        try:
-            add_uv_coords(mesh, bm)
-        except Exception as ex:
-            _report(f"Skipping converting uv coordinates for {name}: {ex}")
-
-    bm.to_mesh(blender_mesh)
-    bm.free()  
-
-    return blender_mesh
-
-
-"""
-Curves
-"""
-
-def line_to_native(speckle_curve: Line, blender_curve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    if not speckle_curve.end: return []
-
-    line = blender_curve.splines.new("POLY")
-    line.points.add(1)
-
-    line.points[0].co = (
-        float(speckle_curve.start.x) * scale,
-        float(speckle_curve.start.y) * scale,
-        float(speckle_curve.start.z) * scale,
-        1,
-    )
-
-    line.points[1].co = (
-        float(speckle_curve.end.x) * scale,
-        float(speckle_curve.end.y) * scale,
-        float(speckle_curve.end.z) * scale,
-        1,
-    )
-
-    return [line]
-
-
-def polyline_to_native(scurve: Polyline, bcurve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    if not (value := scurve.value): return []
-    N = len(value) // 3
-
-    polyline = bcurve.splines.new("POLY")
-
-    if hasattr(scurve, "closed"):
-        polyline.use_cyclic_u = scurve.closed or False
-
-    polyline.points.add(N - 1)
-    for i in range(N):
-        polyline.points[i].co = (
-            float(value[i * 3]) * scale,
-            float(value[i * 3 + 1]) * scale,
-            float(value[i * 3 + 2]) * scale,
-            1,
-        )
-
-    return [polyline]
-    
-
-
-def nurbs_to_native(scurve: Curve, bcurve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    if not (points := scurve.points): return []
-    if not scurve.degree: raise Exception("curve is missing degree")
-    if not scurve.weights: raise Exception("curve is missing weights")
-
-    # Closed curves from rhino will have n + degree points. We ignore the extras
-    num_points = len(points) // 3 - scurve.degree if (scurve.closed) else (
-        len(points) // 3)   
-    
-    nurbs = bcurve.splines.new("NURBS")
-    nurbs.use_cyclic_u = scurve.closed or False
-    nurbs.use_endpoint_u = not scurve.periodic
-    
-    nurbs.points.add(num_points - 1)
-    use_weights = len(scurve.weights) >= num_points
-    for i in range(num_points):
-        nurbs.points[i].co = (
-            float(points[i * 3]) * scale,
-            float(points[i * 3 + 1]) * scale,
-            float(points[i * 3 + 2]) * scale,
-            1,
-        )
-        
-        nurbs.points[i].weight = scurve.weights[i] if use_weights else 1
-
-    nurbs.order_u = scurve.degree + 1
-
-    return [nurbs]
-
-
-def arc_to_native(rcurve: Arc, bcurve: bpy.types.Curve, scale: float) -> Optional[bpy.types.Spline]:
-    # TODO: improve Blender representation of arc - check autocad test stream
-    if not rcurve.radius: raise Exception("curve is missing radius")
-    if not rcurve.startAngle: raise Exception("curve is missing startAngle")
-    if not rcurve.endAngle: raise Exception("curve is missing endAngle")
-
-    plane = rcurve.plane
-    if not plane:
-        return None
-
-    normal = MVector([plane.normal.x, plane.normal.y, plane.normal.z])
-
-    radius = rcurve.radius * scale
-    startAngle = rcurve.startAngle
-    endAngle = rcurve.endAngle
-
-    startQuat = MQuaternion(normal, startAngle) # type: ignore
-    endQuat = MQuaternion(normal, endAngle) # type: ignore
-
-    # Get start and end vectors, centre point, angles, etc.
-    r1 = MVector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r1.rotate(startQuat)
-
-    r2 = MVector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r2.rotate(endQuat)
-
-    c = MVector([plane.origin.x, plane.origin.y, plane.origin.z]) * scale
-
-    spt = c + r1 * radius
-    ept = c + r2 * radius
-
-    angle = endAngle - startAngle
-
-    t1 = normal.cross(r1)
-
-    # Initialize arc data and calculate subdivisions
-    arc = bcurve.splines.new("NURBS")
-
-    arc.use_cyclic_u = False
-
-    Ndiv = max(int(math.floor(angle / 0.3)), 2)
-    step = angle / float(Ndiv)
-    stepQuat = MQuaternion(normal, step) # type: ignore
-    tan = math.tan(step / 2) * radius
-
-    arc.points.add(Ndiv + 1)
-
-    # Set start and end points
-    arc.points[0].co = (spt.x, spt.y, spt.z, 1)
-    arc.points[Ndiv + 1].co = (ept.x, ept.y, ept.z, 1)
-
-    # Set intermediate points
-    for i in range(Ndiv):
-        t1 = normal.cross(r1)
-        pt = c + r1 * radius + t1 * tan
-        arc.points[i + 1].co = (pt.x, pt.y, pt.z, 1)
-        r1.rotate(stepQuat)
-
-    # Set curve settings
-    arc.use_endpoint_u = True
-    arc.order_u = 3
-
-    return arc
-
-
-def polycurve_to_native(scurve: Polycurve, bcurve: bpy.types.Curve, scale: float) -> list[bpy.types.Spline]:
-    """
-    Convert Polycurve object
-    """
-    if not scurve.segments: raise Exception("curve is missing segments")
-
-    curves = []
-
-    for seg in scurve.segments:
-        speckle_type = type(seg)
-
-        if speckle_type in SUPPORTED_CURVES:
-            curves.append(icurve_to_native_spline(seg, bcurve, scale))
-        else:
-            _report(f"Unsupported curve type: {speckle_type}")
-
-    return curves
- 
-def ellipse_to_native(ellipse: Union[Ellipse, Circle], bcurve: bpy.types.Curve, units_scale: float) -> List[bpy.types.Spline]:
-    if not ellipse.plane: raise Exception("curve is missing plane")
-
-    radX: float
-    radY: float
-    if isinstance(ellipse, Ellipse):
-        if not ellipse.firstRadius: raise Exception("curve is missing firstRadius")
-        if not ellipse.secondRadius: raise Exception("curve is missing secondRadius")
-
-        radX = ellipse.firstRadius * units_scale
-        radY = ellipse.secondRadius * units_scale
-    else:
-        if not ellipse.radius: raise Exception("curve is missing radius")
-
-        radX = ellipse.radius * units_scale
-        radY = ellipse.radius * units_scale
-
-    
-    D = 0.5522847498307936 # (4/3)*tan(pi/8)
-
-    right_handles = [
-        (+radX,     +radY * D,  0.0),
-        (-radX * D, +radY,      0.0),
-        (-radX,     -radY * D,  0.0),
-        (+radX * D, -radY,      0.0),
-    ]
-
-    left_handles = [
-        (+radX,     -radY * D,  0.0),
-        (+radX * D, +radY,      0.0),
-        (-radX,     +radY * D,  0.0),
-        (-radX * D, -radY,      0.0),
-    ]
-
-    points = [
-        (+radX, 0.0,   0.0),
-        (0.0,   +radY, 0.0),
-        (-radX, 0.0,   0.0),
-        (0.0,   -radY, 0.0),
-    ]
-    transform = plane_to_native_transform(ellipse.plane, units_scale)
-
-    spline = bcurve.splines.new("BEZIER")
-    spline.bezier_points.add(len(points) - 1)
-
-    for i in range(len(points)):
-        spline.bezier_points[i].co = transform @ MVector(points[i]) # type: ignore
-        spline.bezier_points[i].handle_left = transform @ MVector(left_handles[i]) # type: ignore
-        spline.bezier_points[i].handle_right = transform @ MVector(right_handles[i]) # type: ignore
-
-    spline.use_cyclic_u = True
-    
-    #TODO support trims?
-    return [spline]
-
-
-def icurve_to_native_spline(speckle_curve: Base, blender_curve: bpy.types.Curve, scale: float) -> List[bpy.types.Spline]:
-    # polycurves
-    if isinstance(speckle_curve, Polycurve):
-        return polycurve_to_native(speckle_curve, blender_curve, scale)
-
-    splines: List[bpy.types.Spline]
-    # single curves
-    if isinstance(speckle_curve, Line):
-        splines = line_to_native(speckle_curve, blender_curve, scale)
-    elif isinstance(speckle_curve, Curve):
-        splines = nurbs_to_native(speckle_curve, blender_curve, scale)
-    elif isinstance(speckle_curve, Polyline):
-        splines = polyline_to_native(speckle_curve, blender_curve, scale)
-    elif isinstance(speckle_curve, Arc):
-        spline = arc_to_native(speckle_curve, blender_curve, scale)
-        splines = [spline] if spline else []
-    elif isinstance(speckle_curve, Ellipse) or isinstance(speckle_curve, Circle):
-        splines = ellipse_to_native(speckle_curve, blender_curve, scale)
-    else:
-        raise TypeError(f"{speckle_curve} is not a supported curve type. Supported types: {SUPPORTED_CURVES}")
-
-    return splines
-
-
-def icurve_to_native(speckle_curve: Base, name: str, scale: float) -> bpy.types.Curve:
-    curve_type = type(speckle_curve)
-    if curve_type not in SUPPORTED_CURVES:
-        raise Exception(f"Unsupported curve type: {curve_type}")
-
-    blender_curve = (
-        bpy.data.curves[name]
-        if name in bpy.data.curves.keys()
-        else bpy.data.curves.new(name, type="CURVE")
-    )
-    blender_curve.dimensions = "3D"
-    blender_curve.resolution_u = 12 #TODO: We could maybe decern the resolution from the polyline displayValue
-
-    icurve_to_native_spline(speckle_curve, blender_curve, scale)
-
-    return blender_curve
-
-
-"""
-Transforms and Instances
-"""
-
-def transform_to_native(transform: Transform, scale: float) -> MMatrix:
-    mat = MMatrix(
-        [
-            transform.value[:4],
-            transform.value[4:8],
-            transform.value[8:12],
-            transform.value[12:16],
-        ]
-    )
-    # scale the translation
-    for i in range(3):
-        mat[i][3] *= scale
-    return mat
-
-def plane_to_native_transform(plane: Plane, fallback_scale:float = 1) -> MMatrix:
-    scale_factor = get_scale_factor(plane, fallback_scale)
-    tx = (plane.origin.x * scale_factor)
-    ty = (plane.origin.y * scale_factor)
-    tz = (plane.origin.z * scale_factor)
-
-
-    return MMatrix((
-        (plane.xdir.x,  plane.ydir.x,  plane.normal.x, tx),
-        (plane.xdir.y,  plane.ydir.y,  plane.normal.y, ty),
-        (plane.xdir.z,  plane.ydir.z,  plane.normal.z, tz),
-        (0,             0,             0,              1 )
-    ))
-
-
-"""
-Instances / Blocks
-"""
-
-def _get_instance_name(instance: Instance) -> str:
-    if not instance.definition: raise Exception("Instance is missing a definition")
-    name_prefix = (
-        _get_friendly_object_name(instance) 
-        or _get_friendly_object_name(instance.definition) 
-        or _simplified_speckle_type(instance.speckle_type)
-    )
-    return f"{name_prefix}{OBJECT_NAME_SPECKLE_SEPARATOR}{instance.id}"
-
-
-def instance_to_native_object(instance: Instance, scale: float) -> Object:
-    """
-    Converts Instance to a unique object with (potentially) shared data (linked duplicate)
-    """
-    if not instance.definition: raise Exception("Instance is missing a definition")
-    if not instance.transform: raise Exception("Instance is missing a transform")
-    definition = instance.definition
-    if not definition.id: raise Exception("Instance is missing a valid definition")
-
-    name = _get_instance_name(instance)
-
-    native_instance: Optional[Object] = None
-    converted_objects: Dict[str, Union[Object, BCollection]] = {}
-    traversal_root: Base = definition
-    
-    if not can_convert_to_native(definition):
-        # Non-convertible (like all blocks, and some revit instances) will not be converted as part of the deep_traversal.
-        # so we explicitly convert them as empties.
-        native_instance = create_new_object(None, name) 
-        native_instance.empty_display_size = 0
-
-        converted_objects["__ROOT"] = native_instance # we create a dummy root to avoid id conflicts, since revit definitions have displayValues, they are convertible
-        traversal_root = Base(elements=definition, id="__ROOT")
-
-    #Convert definition + "elements" on definition
-    _deep_conversion(traversal_root, converted_objects, False)
-
-    if not native_instance:
-        assert(can_convert_to_native(definition))
-
-        if not definition.id in converted_objects:
-            raise Exception("Definition was not converted")
-
-        converted = converted_objects[definition.id]
-
-        if not isinstance(converted, Object):
-            raise Exception("Definition was not converted to an Object")
-        
-        native_instance = converted
-
-    instance_transform = transform_to_native(instance.transform, scale)
-    native_instance.matrix_world = instance_transform
-
-    return native_instance
-
-def instance_to_native_collection_instance(instance: Instance, scale: float) -> bpy.types.Object:
-    """
-    Convert an Instance as a transformed Object with the `instance_collection` property
-    set to be the `instance.Definition` converted as a collection
-
-    The definition collection won't be linked to the current scene
-    Any Elements on the instance object will also be converted (and spacially transformed)
-    """
-    if not instance.definition: raise Exception("Instance is missing a definition")
-    if not instance.transform: raise Exception("Instance is missing a transform")
-
-    name = _get_instance_name(instance)
-
-    # Get/Convert definition collection
-    collection_def = _instance_definition_to_native(instance.definition)
-
-    instance_transform = transform_to_native(instance.transform, scale)
-
-    native_instance = create_new_object(None, name)
-
-    #add_custom_properties(instance, native_instance)
-    # hide the instance axes so they don't clutter the viewport
-    native_instance.empty_display_size = 0
-    native_instance.instance_collection = collection_def
-    native_instance.instance_type = "COLLECTION"
-    native_instance.matrix_world = instance_transform
-        
-    return native_instance 
-
-def _instance_definition_to_native(definition: Union[Base, BlockDefinition]) -> bpy.types.Collection:
-    """
-    Converts a geometry carrying Base as a collection (does not link it to the scene)
-    """
-    name = _generate_object_name(definition)
-    native_def = bpy.data.collections.get(name)
-    if native_def:
-        return native_def
-
-    native_def = create_new_collection(name)
-    native_def["applicationId"] = definition.applicationId
-
-    converted_objects = {}
-    converted_objects["__ROOT"] = native_def # we create a dummy root to avoid id conflicts, since revit definitions have displayValues, they are convertible
-    dummyRoot = Base(elements=definition, id="__ROOT")
-
-    _deep_conversion(dummyRoot, converted_objects, True)
-
-    return native_def
-
-def _deep_conversion(root: Base, converted_objects: Dict[str, Union[Object, BCollection]], preserve_transform: bool):
-    traversal_func = get_default_traversal_func(can_convert_to_native)
-
-    for item in traversal_func.traverse(root):
-        
-        current: Base = item.current
-        if can_convert_to_native(current) or isinstance(current, SCollection):
-            try:
-                if not current or not current.id: raise Exception(f"{current} was an invalid speckle object")
-
-                #Convert the object!
-                converted_data_type: str
-                converted: Union[Object, BCollection, None]
-                if isinstance(current, SCollection):
-                    if(current.collectionType == "Scene Collection"): raise ConversionSkippedException()
-                    converted = collection_to_native(current)
-                    converted_data_type = "COLLECTION"
-                else:
-                    converted = convert_to_native(current)
-                    converted_data_type = "COLLECTION_INSTANCE" if converted.instance_collection else str(converted.type)
-                
-                if converted is None:
-                    raise Exception("Conversion returned None")
-                    
-                converted_objects[current.id] = converted
-
-                add_to_hierarchy(converted, item, converted_objects, preserve_transform)
-
-                _report(f"Successfully converted {type(current).__name__} {current.id} as '{converted_data_type}'")
-            except ConversionSkippedException as ex:
-                _report(f"Skipped converting {type(current).__name__} {current.id}: {ex}")
-            except Exception as ex:
-                _report(f"Failed to converted {type(current).__name__} {current.id}: {ex}")
-
-def collection_to_native(collection: SCollection) -> BCollection: 
-    name = collection.name or f"{collection.collectionType} -- {collection.applicationId or collection.id}"  #TODO: consider consolidating name formatting with Rhino
-    ret =  get_or_create_collection(name)
-
-    color = getattr(collection, "colorTag", None)
-    if color:
-        ret.color_tag = color
-
-    return ret
-
-def get_or_create_collection(name: str, clear_collection: bool = True) -> BCollection:
-    #Disabled for now, since update mode needs rescoping.
-    # existing = cast(Optional[BCollection], bpy.data.collections.get(name))
-    # if existing:
-    #     if clear_collection:
-    #         for obj in existing.objects:
-    #             existing.objects.unlink(obj)
-    #     return existing
-    # else:
-    new_collection = create_new_collection(name)
-
-    #NOTE: We want to not render revit "Rooms" collections by default.
-    if name == "Rooms":
-        new_collection.hide_viewport = True
-        new_collection.hide_render = True
-
-    return new_collection
-    
-    
-
-"""
-Object Naming and Creation
-"""
-
-def create_new_collection( desired_name: str) -> bpy.types.Collection:
-    """
-    Creates a new blender collection with a unique name
-    If the desired_name is already taken
-    we'll append a number, with the format .xxx to the desired_name to ensure the name is unique.
-    """
-    name = _make_unique_name(desired_name, bpy.data.collections.keys())
-
-    blender_collection = bpy.data.collections.new(name)
-    return blender_collection
-
-def create_new_object(obj_data: Optional[bpy.types.ID], desired_name: str) -> bpy.types.Object:
-    """
-    Creates a new blender object with a unique name,
-    If the desired_name is already taken
-    we'll append a number, with the format .xxx to the desired_name to ensure the name is unique.
-    """
-    name = _make_unique_name(desired_name, bpy.data.objects.keys())
-
-    blender_object = bpy.data.objects.new(name, obj_data)
-    return blender_object
-
-def _make_unique_name( desired_name: str, taken_names: Collection[str], counter: int = 0) -> str:
-    """
-    Using Blenders default naming (append numeral in .xxx format) to avoid name conflicts with taken names
-    """
-    name = desired_name if counter == 0 else f"{desired_name[:OBJECT_NAME_MAX_LENGTH - 4]}{OBJECT_NAME_NUMERAL_SEPARATOR}{counter:03d}"  # format counter as name.xxx, truncate to ensure we don't exceed the object name max length
-
-    #TODO: This is very slow, and gets slower the more objects you receive with the same name...
-    # We could use a binary/galloping search, and/or cache the name -> index within a receive.
-    if name in taken_names:
-        #Name already taken, increment counter and try again!
-        return _make_unique_name(desired_name, taken_names, counter + 1)
-
-    return name
-
-
-def _get_friendly_object_name(speckle_object: Base) -> Optional[str]:
-    return (getattr(speckle_object, "name", None)
-        or getattr(speckle_object, "Name", None)
-        or _get_revit_family_name(speckle_object)
-        )
-
-def _get_revit_family_name(speckle_object: Base) -> Optional[str]:
-    family = getattr(speckle_object, "family", None)
-    family_type = getattr(speckle_object, "type", None)
-
-    if family and family_type:
-        return f"{family_type}-{family}"
-    else:
-        return None
-
-# Blender object names must not exceed 62 characters
-# We need to ensure the complete ID is included in the name (to prevent identity collisions)
-# So we if the name is too long, we need to truncate
-def _truncate_object_name(name: str) -> str:
-
-    MAX_NAME_LENGTH = OBJECT_NAME_MAX_LENGTH - SPECKLE_ID_LENGTH - len(OBJECT_NAME_SPECKLE_SEPARATOR)
-
-    return name[:MAX_NAME_LENGTH]
-    
-
-def _simplified_speckle_type(speckle_type: str) -> str:
-    return(speckle_type.rsplit('.')[-1]) #Take only the most specific object type name (without namespace)
-
-def _generate_object_name(speckle_object: Base) -> str:
-    prefix: str
-    name = _get_friendly_object_name(speckle_object)
-    if name:
-        prefix = _truncate_object_name(name)
-    else:
-        prefix = _simplified_speckle_type(speckle_object.speckle_type)
-
-    return f"{prefix}{OBJECT_NAME_SPECKLE_SEPARATOR}{speckle_object.id}"
-
-
-def get_scale_factor(speckle_object: Base, fallback: float = 1.0) -> float:
-    scale = fallback
-    if units := getattr(speckle_object, "units", None):
-        scale = get_scale_length(units) / bpy.context.scene.unit_settings.scale_length
-    return scale

bpy_speckle/convert/to_speckle.py

@@ -1,541 +0,0 @@
-from typing import Dict, Iterable, List, Optional, Tuple, Union, cast
-import bpy
-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,
-)
-from bpy_speckle.functions import _report
-
-
-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", "FONT", "SURFACE", "META")
-
-
-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:
-        raise ConversionSkippedException(f"Objects of type {blender_type} are not supported")
-
-    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, cast(NMesh, blender_object.data))
-    elif blender_type == "CURVE":
-        converted = curve_to_speckle(blender_object, cast(NCurve, blender_object.data))
-    elif blender_type == "EMPTY":
-        converted = empty_to_speckle(blender_object)
-    elif blender_type == "CAMERA":
-        converted = camera_to_speckle_view(blender_object, cast(NCamera, blender_object.data))
-    elif blender_type == "FONT" or "SURFACE" or "META":
-        converted = anything_to_speckle_mesh(blender_object)
-    if not converted:
-        raise Exception("Conversion returned None")
-
-    converted["properties"] = get_blender_custom_properties(raw_blender_object) #NOTE: Depsgraph copies don't have custom properties so we use the raw version
-
-    # 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
-        )
-
-    return converted
-
-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] 
-
-    # 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 bezier_to_speckle(matrix: MMatrix, spline: bpy.types.Spline, name: Optional[str] = None) -> Curve:
-    degree = 3
-    closed = spline.use_cyclic_u
-    points: List[Tuple[MVector]] = []
-    for i, bp in enumerate(spline.bezier_points):
-        if i > 0:
-            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 * UnitsScale)) # type: ignore
-
-    if closed:
-        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
-
-    for i in range(1, len(knots)):
-        knots[i] = i // 3
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Curve(
-        name=name,
-        degree=degree,
-        closed=spline.use_cyclic_u,
-        periodic= not spline.use_endpoint_u,
-        points=flattened_points,
-        weights=[1] * num_points,
-        knots=knots,
-        rational=True,
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=Units,
-        bbox=Box(area=0.0, volume=0.0),
-        displayValue = bezier_to_speckle_polyline(matrix, spline, length),
-    )
-
-
-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= not spline.use_endpoint_u,
-        points=flattened_points,
-        weights=weights,
-        knots=knots,
-        rational=is_rational, 
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        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)
-
-        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=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,
-    )
-
-
-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
-
-    b["name"] = to_speckle_name(blender_object)
-    b["@elements"] = curves
-    return b
-
-def curve_to_speckle_geometry(blender_object: Object, data: bpy.types.Curve) -> Tuple[List[Mesh], List[Base]]:
-    assert(blender_object.type == "CURVE")
-
-    blender_object = cast(Object, blender_object.evaluated_get(bpy.context.view_layer.depsgraph))
-
-    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:
-        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(matrix, spline, to_speckle_name(blender_object)))
-
-        elif spline.type == "NURBS":
-            curves.append(nurbs_to_speckle(matrix, spline, to_speckle_name(blender_object)))
-
-        elif spline.type == "POLY":
-            curves.append(poly_to_speckle(matrix, spline, to_speckle_name(blender_object)))
-
-    return (meshes, curves)
-
-def anything_to_speckle_mesh(blender_object: Object) -> Base:
-
-    mesh = mesh_to_speckle(blender_object, blender_object.to_mesh())
-    blender_object.to_mesh_clear()
-    return mesh
-
-@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":
-        return None
-
-    mat = blender_object.matrix_world
-
-    verts = data.vertices
-    polylines = []
-    for i, poly in enumerate(data.polygons):
-        value = []
-        for v in poly.vertices:
-            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,
-            length=0,
-            domain=domain,
-            bbox=Box(area=0.0, volume=0.0),
-            area=0,
-            units=UNITS,
-        )
-
-        polylines.append(poly)
-
-    return polylines
-
-
-def material_to_speckle(blender_mat: bpy.types.Material) -> RenderMaterial:
-    speckle_mat = RenderMaterial()
-    speckle_mat.name = blender_mat.name
-
-    if blender_mat.use_nodes:
-        if blender_mat.node_tree.nodes.get("Principled BSDF"):
-            inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-            emission_color = "Emission" if "Emission" in inputs else "Emission Color" # type: ignore 
-            
-            speckle_mat.diffuse = to_argb_int(inputs["Base Color"].default_value) # type: ignore
-            speckle_mat.emissive = to_argb_int(inputs[emission_color].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
-
-    # 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 = cast(MVector, matrix.col[1].xyz)
-    forwards = cast(MVector, -matrix.col[2].xyz)
-    translation = matrix.translation
-
-    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] *= UnitsScale
-
-    return Transform(value=value, units=Units)
-
-
-def block_def_to_speckle(blender_definition: bpy.types.Collection) -> BlockDefinition:
-    geometryBuilder = BlenderCommitObjectBuilder()
-    for geo in blender_definition.objects:
-        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=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) #TODO: remove?
-    return block_def
-
-
-def block_instance_to_speckle(blender_instance: Object) -> BlockInstance:
-    return BlockInstance(
-        blockDefinition=block_def_to_speckle(
-            blender_instance.instance_collection
-        ),
-        transform=transform_to_speckle(blender_instance.matrix_world),
-        name=to_speckle_name(blender_instance),
-        units=Units,
-    )
-
-
-def empty_to_speckle(blender_object: Object) -> Union[BlockInstance, Base]:
-    # probably an instance collection (block) so let's try it
-
-    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)

bpy_speckle/convert/util.py

@@ -1,493 +0,0 @@
-import math
-from typing import Any, Dict, Optional, Tuple, Union, cast
-from bmesh.types import BMesh
-import bpy, idprop
-
-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, NodeInputs
-
-from specklepy.objects.graph_traversal.traversal import TraversalContext
-
-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
-    green = ((argb_int >> 8) & 255) / 255
-    blue = (argb_int & 255) / 255
-
-    return (red, green, blue, alpha)
-
-
-def to_argb_int(rgba_color: list[float]) -> int:
-    """Converts an RGBA array to an ARGB integer"""
-    argb_color = rgba_color[-1:] + rgba_color[:3]
-    int_color = [int(val * 255) for val in argb_color]
-
-    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: Base, blender_object: Object):
-    if blender_object is None:
-        return
-
-    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
-
-        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 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 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
-        # that enables this as the blender mats will prob be much more complex than whatever is coming in
-        blender_mat.use_nodes = True
-        inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-
-        inputs["Base Color"].default_value = to_rgba(speckle_mat.diffuse) # 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
-
-        # Blender >=4.0 use "Emission Color"
-        emission_color = "Emission" if "Emission" in inputs else "Emission Color" # type: ignore 
-        inputs[emission_color].default_value = to_rgba(speckle_mat.emissive) # type: ignore
-
-    if speckle_mat.opacity < 1.0:
-        blender_mat.blend_method = "BLEND"
-
-    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: Mesh, blender_mesh: BMesh, scale=1.0):
-    sverts = speckle_mesh.vertices
-
-    if sverts and len(sverts) > 0:
-        for i in range(0, len(sverts), 3):
-            blender_mesh.verts.new(
-                (
-                    float(sverts[i]) * scale,
-                    float(sverts[i + 1]) * scale,
-                    float(sverts[i + 2]) * scale,
-                )
-            )
-
-
-
-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):
-            n = sfaces[i]
-            if n < 3:
-                n += 3  # 0 -> 3, 1 -> 4
-
-            i += 1
-            try:
-                f = blender_mesh.faces.new(
-                    [blender_mesh.verts[x + indexOffset] for x in sfaces[i : i + n]]
-                )
-                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
-
-
-def add_colors(speckle_mesh: Mesh, blender_mesh: BMesh):
-
-    scolors = speckle_mesh.colors
-
-    if scolors:
-        colors = []
-        if len(scolors) > 0:
-
-            for i in range(len(scolors)):
-                argb = int(scolors[i])
-                (a, r, g, b) = argb_split(argb)
-                colors.append(
-                    (
-                        float(r) / 255.0,
-                        float(g) / 255.0,
-                        float(b) / 255.0,
-                        float(a) / 255.0,
-                    )
-                )
-
-        # Make vertex colors
-        if len(scolors) == len(blender_mesh.verts):
-            color_layer = blender_mesh.loops.layers.color.new("Col")
-
-            for face in blender_mesh.faces:
-                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
-
-    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 = []
-
-        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: {len(s_uvs) // 2}"
-            )
-            return
-
-        # 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
-
-
-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: 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 keys
-            if not key.startswith("_")
-        }
-
-    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: 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: bpy.types.Spline) -> int:
-    return nu.point_count_u if nu.use_cyclic_u else nu.point_count_u - 1
-
-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)
-    else:
-        calc_knots(knots, nu.point_count_u, nu.order_u, flag)
-    return knots
-
-
-def calc_knots(knots: list[float], point_count: int, order: int, flag: int) -> None:
-    pts_order = point_count + order
-    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: # CU_NURB_BEZIER
-        if order == 4:
-            k = 0.34
-            for a in range(pts_order):
-                knots[a] = math.floor(k)
-                k += 1.0 / 3.0
-        elif order == 3:
-            k = 0.6
-            for a in range(pts_order):
-                if a >= order and a <= point_count:
-                    k += 0.5
-                    knots[a] = math.floor(k)
-    else:
-        for a in range(1, len(knots) - 1):
-            knots[a] = a - 1
-
-        knots[-1] = knots[-2]
-
-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]
-
-    # 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:
-        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
-
-        nextParent = nextParent.parent
-
-    # 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

bpy_speckle/converter/__init__.py

@@ -0,0 +1,2 @@
+from ..converter.to_native import * #noqa: F403
+from ..converter.utils import *  # noqa: F403

bpy_speckle/converter/utils.py

@@ -0,0 +1,179 @@
+from typing import Tuple, List, Optional
+import bpy
+import mathutils
+from specklepy.objects import Base
+from specklepy.objects.graph_traversal.default_traversal import (
+    create_default_traversal_function,
+)
+
+
+def to_rgba(argb_int: int) -> Tuple[float, float, float, float]:
+    """
+    converts the int representation of a colour into a RGBA tuple
+    """
+    alpha = ((argb_int >> 24) & 255) / 255
+    red = ((argb_int >> 16) & 255) / 255
+    green = ((argb_int >> 8) & 255) / 255
+    blue = (argb_int & 255) / 255
+    return (red, green, blue, alpha)
+
+
+def to_argb_int(rgba_color: List[float]) -> int:
+    """
+    converts an RGBA array to an ARGB integer
+    """
+    argb_color = rgba_color[-1:] + rgba_color[:3]
+    int_color = [int(val * 255) for val in argb_color]
+    return int.from_bytes(int_color, byteorder="big", signed=True)
+
+
+def create_material_from_proxy(
+    render_material, material_name: str
+) -> bpy.types.Material:
+    """
+    creates a Blender material from a Speckle RenderMaterial
+    """
+    if material_name in bpy.data.materials:
+        return bpy.data.materials[material_name]
+
+    # create new material
+    material = bpy.data.materials.new(name=material_name)
+    material.use_nodes = True
+    node_tree = material.node_tree
+    nodes = node_tree.nodes
+
+    for node in nodes:
+        nodes.remove(node)
+
+    bsdf = nodes.new(type="ShaderNodeBsdfPrincipled")
+    output = nodes.new(type="ShaderNodeOutputMaterial")
+
+    node_tree.links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])
+
+    if hasattr(render_material, "diffuse"):
+        diffuse_rgba = to_rgba(render_material.diffuse)
+        bsdf.inputs["Base Color"].default_value = (
+            diffuse_rgba[0],
+            diffuse_rgba[1],
+            diffuse_rgba[2],
+            1.0,
+        )
+
+    if hasattr(render_material, "opacity"):
+        opacity = float(render_material.opacity)
+        if opacity < 1.0:
+            material.blend_method = "BLEND"
+            bsdf.inputs["Alpha"].default_value = opacity
+
+    if hasattr(render_material, "metalness"):
+        metalness = float(render_material.metalness)
+        bsdf.inputs["Metallic"].default_value = metalness
+
+    if hasattr(render_material, "roughness"):
+        roughness = float(render_material.roughness)
+        bsdf.inputs["Roughness"].default_value = roughness
+
+    if (
+        hasattr(render_material, "emissive") and render_material.emissive != -16777216
+    ):  # default black
+        emissive_rgba = to_rgba(render_material.emissive)
+        # only add emission if it's not black (default)
+        if any(val > 0.01 for val in emissive_rgba[:3]):
+            bsdf.inputs["Emission Color"].default_value = (
+                emissive_rgba[0],
+                emissive_rgba[1],
+                emissive_rgba[2],
+                1.0,
+            )
+            bsdf.inputs["Emission Strength"].default_value = 1.0
+
+    return material
+
+
+def transform_matrix(transform: List[float]) -> mathutils.Matrix:
+    """
+    converts a speckle transform array to a 4x4 matrix (blender needs it)
+    """
+
+    if len(transform) != 16:
+        raise ValueError(f"Expected transform with 16 values, got {len(transform)}")
+
+    return mathutils.Matrix(
+        (
+            (transform[0], transform[4], transform[8], transform[12]),
+            (transform[1], transform[5], transform[9], transform[13]),
+            (transform[2], transform[6], transform[10], transform[14]),
+            (transform[3], transform[7], transform[11], transform[15]),
+        )
+    )
+
+
+def find_object_by_id(root_object: Base, target_id: str) -> Optional[Base]:
+    """
+    finds an object using traversal, checking both id and applicationId
+    """
+    if hasattr(root_object, "__closure") and root_object.__closure:
+        if target_id in root_object.__closure:
+            if hasattr(root_object, "elements"):
+                for element in root_object.elements:
+                    if hasattr(element, "id") and element.id == target_id:
+                        return element
+                    if (
+                        hasattr(element, "referencedId")
+                        and element.referencedId == target_id
+                    ):
+                        return find_object_by_id(root_object, element.referencedId)
+
+            if hasattr(root_object, "@elements"):
+                for element in root_object["@elements"]:
+                    if hasattr(element, "id") and element.id == target_id:
+                        return element
+                    if (
+                        hasattr(element, "referencedId")
+                        and element.referencedId == target_id
+                    ):
+                        return find_object_by_id(root_object, element.referencedId)
+
+    traversal_function = create_default_traversal_function()
+
+    for traversal_item in traversal_function.traverse(root_object):
+        obj = traversal_item.current
+
+        if not hasattr(obj, "id"):
+            continue
+
+        if obj.id == target_id:
+            return obj
+
+        if hasattr(obj, "applicationId"):
+            app_id = obj.applicationId
+            if app_id == target_id:
+                return obj
+
+    def deep_search(search_obj):
+        if hasattr(search_obj, "id") and search_obj.id == target_id:
+            return search_obj
+
+        elements_attrs = ["elements", "@elements"]
+        for attr in elements_attrs:
+            if hasattr(search_obj, attr):
+                elements = getattr(search_obj, attr)
+                if elements and isinstance(elements, list):
+                    for element in elements:
+                        if hasattr(element, "id") and element.id == target_id:
+                            return element
+                        if (
+                            hasattr(element, "referencedId")
+                            and element.referencedId == target_id
+                        ):
+                            ref_obj = find_object_by_id(
+                                root_object, element.referencedId
+                            )
+                            if ref_obj:
+                                return ref_obj
+                        result = deep_search(element)
+                        if result:
+                            return result
+        return None
+
+    return deep_search(root_object)

bpy_speckle/functions.py

@@ -1,45 +0,0 @@
-from typing import Callable
-from specklepy.objects.base import Base
-from bpy_speckle.convert.constants import ELEMENTS_PROPERTY_ALIASES
-
-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: object) -> None:
-    """
-    Function for printing messages to the console
-    """
-    print("SpeckleBlender: {}".format(msg))
-
-
-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))
-
-
-def get_default_traversal_func(can_convert_to_native: Callable[[Base], bool]) -> GraphTraversal:
-    """
-    Traversal func for traversing a speckle commit object
-    """
-    
-    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 _: [],
-    )
-
-    convertible_rule = TraversalRule(
-    [can_convert_to_native],
-    lambda _: ELEMENTS_PROPERTY_ALIASES,
-    )
-
-
-    default_rule = TraversalRule(
-    [lambda _: True],
-    lambda o: o.get_member_names(), #TODO: avoid deprecated members
-    )
-
-    return GraphTraversal([ignore_rule, convertible_rule, default_rule])

bpy_speckle/installer.py

@@ -135,6 +135,24 @@ def ensure_pip() -> None:
         raise Exception(f"Failed to install pip, got {completed_process.returncode} return code")
 
 
+def is_uv_available() -> bool:
+    try:
+        import_module("uv")  # noqa F401
+        return True
+    except ImportError:
+        return False
+
+
+def ensure_uv() -> None:
+    print("Installing uv... ")
+    from subprocess import run
+    completed_process = run([PYTHON_PATH, "-m", "pip", "install", "uv"])
+    if completed_process.returncode == 0:
+        print("Successfully installed uv")
+    else:
+        raise Exception(f"Failed to install uv, 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")
@@ -166,14 +184,11 @@ def install_requirements(host_application: str) -> None:
         [
             PYTHON_PATH,
             "-m",
+            "uv",
             "pip",
-            "-q",
-            "--disable-pip-version-check",
             "install",
-            "--prefer-binary",
-            "--ignore-installed",
-            "--no-compile",
-            "-t",
+            "--system",
+            "--target",
             str(path),
             "-r",
             str(requirements_path),
@@ -183,7 +198,7 @@ def install_requirements(host_application: str) -> None:
     )
 
     if completed_process.returncode != 0:
-        m = f"Failed to install dependencies through pip, got {completed_process.returncode} return code"
+        m = f"Failed to install dependencies through uv, got {completed_process.returncode} return code"
         print(m)
         raise Exception(m)
     
@@ -196,6 +211,9 @@ def install_requirements(host_application: str) -> None:
 def install_dependencies(host_application: str) -> None:
     if not is_pip_available():
         ensure_pip()
+    
+    if not is_uv_available():
+        ensure_uv()
 
     install_requirements(host_application)
 

bpy_speckle/operators/__init__.py

@@ -1,64 +0,0 @@
-from .users import LoadUsers, LoadUserStreams, ResetUsers
-from .object import (
-    UpdateObject,
-    ResetObject,
-    DeleteObject,
-    UploadNgonsAsPolylines,
-    SelectIfSameCustomProperty,
-    SelectIfHasCustomProperty,
-)
-from .streams import (
-    ReceiveStreamObjects,
-    SendStreamObjects,
-    ViewStreamDataApi,
-    DeleteStream,
-    SelectOrphanObjects,
-)
-from .streams import (
-    AddStreamFromURL,
-    CreateStream,
-    CopyStreamId,
-    CopyCommitId,
-    CopyBranchName,
-    CopyModelId,
-)
-from .commit import DeleteCommit
-from .misc import OpenSpeckleGuide, OpenSpeckleTutorials, OpenSpeckleForum
-
-operator_classes = [
-    LoadUsers,
-    ResetUsers,
-    ReceiveStreamObjects,
-    SendStreamObjects,
-    LoadUserStreams,
-    CopyStreamId,
-    CopyCommitId,
-    CopyBranchName,
-    CopyModelId,
-]
-
-operator_classes.extend([DeleteCommit])
-
-operator_classes.extend(
-    [
-        UpdateObject,
-        ResetObject,
-        DeleteObject,
-        UploadNgonsAsPolylines,
-        SelectIfSameCustomProperty,
-        SelectIfHasCustomProperty,
-    ]
-)
-
-operator_classes.extend(
-    [
-        ViewStreamDataApi,
-        DeleteStream,
-        SelectOrphanObjects,
-        AddStreamFromURL,
-        CreateStream,
-        OpenSpeckleGuide,
-        OpenSpeckleTutorials,
-        OpenSpeckleForum,
-    ]
-)

bpy_speckle/operators/commit.py

@@ -1,72 +0,0 @@
-"""
-Commit operators
-"""
-import bpy
-from bpy.props import BoolProperty
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.functions import _report
-from bpy_speckle.properties.scene import get_speckle
-from specklepy.logging import metrics
-
-
-class DeleteCommit(bpy.types.Operator):
-    """
-    Permanently deletes the selected version from the selected model.
-    To execute from code, call: `bpy.ops.speckle.delete_commit(are_you_sure=True)`
-    """
-
-    bl_idname = "speckle.delete_commit"
-    bl_label = "Delete Version"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Permanently Deletes the selected version from the selected model"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        default=False,
-    ) # type: ignore
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-
-    def invoke(self, context, event):
-        speckle = get_speckle(context)
-        wm = context.window_manager
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        if not self.are_you_sure:
-            _report("Cancelled by user")
-            return {"CANCELLED"}
-        self.are_you_sure = False
-
-        self.delete_commit(context)
-        return {"FINISHED"}
-
-    @staticmethod
-    def delete_commit(context: bpy.types.Context) -> None: 
-        speckle = get_speckle(context)
-
-        (_, stream, branch, commit) = speckle.validate_commit_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        deleted = client.commit.delete(stream_id=stream.id, commit_id=commit.id)
-
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "delete_commit"
-            },
-        )
-        
-        if not deleted:
-            raise Exception("Delete operation failed")
-
-        print(f"Version {commit.id} ({commit.message}) of model {branch.id} ({branch.name}) has been deleted from project {stream.id} ({stream.name})")
-

bpy_speckle/operators/misc.py

@@ -1,65 +0,0 @@
-import bpy
-import webbrowser
-from specklepy.logging import metrics 
-
-
-
-
-class OpenSpeckleGuide(bpy.types.Operator):
-    _guide_url = "https://speckle.guide/user/blender.html"
-
-    bl_idname = "speckle.open_speckle_guide"
-    bl_label = "Speckle Docs"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = f"Browse the documentation on the Speckle Guide ({_guide_url})"
-    
-    def execute(self, context):
-        webbrowser.open(self._guide_url)
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "OpenSpeckleGuide"
-            },
-        )
-        return {"FINISHED"}
-
-
-class OpenSpeckleTutorials(bpy.types.Operator):
-    _tutorials_url = "https://speckle.systems/tutorials/"
-
-    bl_idname = "speckle.open_speckle_tutorials"
-    bl_label = "Tutorials Portal"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = f"Visit our tutorials portal for learning resources ({_tutorials_url})"
-
-    def execute(self, context):
-        webbrowser.open(self._tutorials_url)
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "OpenSpeckleTutorials"
-            },
-        )
-        return {"FINISHED"}
-
-
-class OpenSpeckleForum(bpy.types.Operator):
-    _forum_url = "https://speckle.community/"
-
-    bl_idname = "speckle.open_speckle_forum"
-    bl_label = "Community Forum"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = f"Ask questions and join the discussion on our community forum ({_forum_url})"
-
-    def execute(self, context):
-        webbrowser.open(self._forum_url)
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "OpenSpeckleForum"
-            },
-        )
-        return {"FINISHED"}

bpy_speckle/operators/object.py

@@ -1,366 +0,0 @@
-"""
-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
-
-@deprecated
-class UpdateObject(bpy.types.Operator):
-    """
-    Update local (receive) or remote (send) object depending on
-    the update direction. If sending, updates the object on the
-    server in-place.
-    """
-
-    bl_idname = "speckle.update_object"
-    bl_label = "Update Object (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    client = None
-
-    def execute(self, context):
-        user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        active = context.active_object
-        _report(active)
-
-        if active is not None and active.speckle.enabled:
-            if active.speckle.send_or_receive == "send" and active.speckle.stream_id:
-                sstream = client.streams.get(active.speckle.stream_id)
-                # res = client.StreamGetAsync(active.speckle.stream_id)['resource']
-                # res = client.streams.get(active.speckle.stream_id)
-
-                if sstream is None:
-                    _report("Getting stream failed.")
-                    return {"CANCELLED"}
-
-                stream_units = "Meters"
-                if sstream.baseProperties:
-                    stream_units = sstream.baseProperties.units
-
-                scale = context.scene.unit_settings.scale_length / get_scale_length(
-                    stream_units
-                )
-
-                sm = convert_to_speckle(active, scale)
-
-                _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"}
-        return {"CANCELLED"}
-
-@deprecated
-class ResetObject(bpy.types.Operator):
-    """
-    Reset Speckle object settings
-    """
-
-    bl_idname = "speckle.reset_object"
-    bl_label = "Reset Object (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-
-        context.object.speckle.send_or_receive = "send"
-        context.object.speckle.stream_id = ""
-        context.object.speckle.object_id = ""
-        context.object.speckle.enabled = False
-        context.view_layer.update()
-
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "ResetObject"
-            },
-        )
-
-        return {"FINISHED"}
-
-@deprecated
-class DeleteObject(bpy.types.Operator):
-    """
-    Delete object from the server and update relevant stream
-    """
-
-    bl_idname = "speckle.delete_object"
-    bl_label = "Delete Object (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-        active = context.object
-        if active.speckle.enabled:
-            res = client.StreamGetAsync(active.speckle.stream_id)
-            existing = [
-                x
-                for x in res["resource"]["objects"]
-                if x["_id"] == active.speckle.object_id
-            ]
-            if existing is None:
-                return {"CANCELLED"}
-            new_objects = [
-                x
-                for x in res["resource"]["objects"]
-                if x["_id"] != active.speckle.object_id
-            ]
-
-            res = client.GetLayers(active.speckle.stream_id)
-            new_layers = res["resource"]["layers"]
-            new_layers[-1]["objectCount"] = new_layers[-1]["objectCount"] - 1
-            new_layers[-1]["topology"] = "0-%s" % new_layers[-1]["objectCount"]
-
-            res = client.StreamUpdateAsync(
-                {"objects": new_objects, "layers": new_layers}, active.speckle.stream_id
-            )
-            res = client.ObjectDeleteAsync(active.speckle.object_id)
-
-            active.speckle.send_or_receive = "send"
-            active.speckle.stream_id = ""
-            active.speckle.object_id = ""
-            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
-    TODO: move to another category of specialized operators and fix to work with API 2.0
-    """
-
-    bl_idname = "speckle.upload_ngons_as_polylines"
-    bl_label = "Upload Ngons As Polylines (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    clear_stream: BoolProperty(
-        name="Clear stream",
-        default=False,
-    )
-
-    def execute(self, context):
-        active = context.active_object
-        if active is not None and active.type == "MESH":
-
-            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]
-
-            # scale = context.scene.unit_settings.scale_length / get_scale_length(
-            #     stream.units
-            # )
-            scale = 1.0
-
-            sp = ngons_to_speckle_polylines(active, scale)
-
-            if sp is None:
-                return {"CANCELLED"}
-
-            placeholders = []
-            for polyline in sp:
-
-                res = client.objects.create([polyline])
-
-                if res is None:
-                    _report(client.me)
-                    continue
-                placeholders.extend(res)
-
-            if not placeholders:
-                return {"CANCELLED"}
-
-                # Get list of existing objects in stream and append new object to list
-            _report("Fetching stream...")
-            sstream = client.streams.get(stream.id)
-
-            if self.clear_stream:
-                _report("Clearing stream...")
-                sstream.objects = placeholders
-                N = 0
-            else:
-                sstream.objects.extend(placeholders)
-
-            N = sstream.layers[-1].objectCount
-            if self.clear_stream:
-                N = 0
-            sstream.layers[-1].objectCount = N + len(placeholders)
-            sstream.layers[-1].topology = "0-%s" % (N + len(placeholders))
-
-            res = client.streams.update(sstream.id, sstream)
-
-            # Update view layer
-            context.view_layer.update()
-            _report("Done.")
-
-            metrics.track(
-                "Connector Action",
-                None, 
-                custom_props={
-                    "name": "UploadNgonsAsPolylines"
-                },
-            )
-        return {"FINISHED"}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "clear_stream")
-
-
-def get_custom_speckle_props(self, context):
-    ignore = ["speckle", "cycles", "cycles_visibility"]
-
-    active = context.active_object
-    if not active:
-        return []
-
-    return [(x, "{}".format(x), "") for x in active.keys()]
-
-@deprecated
-class SelectIfSameCustomProperty(bpy.types.Operator):
-    """
-    Select scene objects if they have the same custom property
-    value as the active object
-    """
-
-    bl_idname = "speckle.select_if_same_custom_props"
-    bl_label = "Select Identical Custom Props (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    custom_prop: EnumProperty(
-        name="Custom properties",
-        description="Available streams associated with user.",
-        items=get_custom_speckle_props,
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "custom_prop")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-    def execute(self, context):
-
-        active = context.active_object
-        if not active:
-            return {"CANCELLED"}
-
-        if self.custom_prop not in active.keys():
-            return {"CANCELLED"}
-
-        value = active[self.custom_prop]
-
-        _report(
-            "Looking for '{}' property with a value of '{}'.".format(
-                self.custom_prop, value
-            )
-        )
-
-        for obj in bpy.data.objects:
-
-            if self.custom_prop in obj.keys() and obj[self.custom_prop] == value:
-                obj.select_set(True)
-            else:
-                obj.select_set(False)
-
-            metrics.track(
-                "Connector Action",
-                None, 
-                custom_props={
-                    "name": "SelectIfSameCustomProperty"
-                },
-            )
-                
-        return {"FINISHED"}
-
-@deprecated
-class SelectIfHasCustomProperty(bpy.types.Operator):
-    """
-    Select scene objects if they have the same custom property
-    as the active object, regardless of the value
-    """
-
-    bl_idname = "speckle.select_if_has_custom_props"
-    bl_label = "Select Same Custom Prop (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-
-    custom_prop: EnumProperty(
-        name="Custom properties",
-        description="Custom properties yo",
-        items=get_custom_speckle_props,
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "custom_prop")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-    def execute(self, context):
-
-        active = context.active_object
-        if not active:
-            return {"CANCELLED"}
-
-        if self.custom_prop not in active.keys():
-            return {"CANCELLED"}
-
-        value = active[self.custom_prop]
-
-        _report("Looking for '{}' property.".format(self.custom_prop))
-
-        for obj in bpy.data.objects:
-
-            if self.custom_prop in obj.keys():
-                obj.select_set(True)
-            else:
-                obj.select_set(False)
-
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "SelectIfHasCustomProperty"
-            },
-        )
-
-
-        return {"FINISHED"}

bpy_speckle/operators/streams.py

@@ -1,864 +0,0 @@
-"""
-Stream operators
-"""
-from math import radians
-from typing import Callable, Dict, Optional, Tuple, Union, cast
-import webbrowser
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    EnumProperty,
-)
-from bpy.types import (
-    Context,
-    Object,
-    Collection
-)
-from deprecated import deprecated
-from bpy_speckle.blender_commit_object_builder import BlenderCommitObjectBuilder
-from bpy_speckle.convert.to_native import (
-    can_convert_to_native,
-    collection_to_native,
-    convert_to_native,
-    set_convert_instances_as,
-)
-from bpy_speckle.convert.to_speckle import (
-    convert_to_speckle,
-)
-from bpy_speckle.functions import (
-    get_default_traversal_func,
-    _report,
-    get_scale_length,
-)
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.operators.users import LoadUserStreams, add_user_stream
-from bpy_speckle.properties.scene import SpeckleSceneSettings, SpeckleStreamObject, SpeckleUserObject, get_speckle, selection_state
-from bpy_speckle.convert.util import ConversionSkippedException, add_to_hierarchy
-from specklepy.core.api.models import Commit
-from specklepy.core.api import operations, host_applications
-from specklepy.core.api.wrapper import StreamWrapper
-from specklepy.core.api.resources.stream import Stream
-from specklepy.transports.server import ServerTransport
-from specklepy.objects import Base
-from specklepy.objects.other import Collection as SCollection
-from specklepy.logging.exceptions import SpeckleException
-from specklepy.logging import metrics
-
-ObjectCallback = Optional[Callable[[bpy.types.Context, Object, Base], Object]]
-ReceiveCompleteCallback = Optional[Callable[[bpy.types.Context, Dict[str, Union[Object, Collection]]], None]]
-
-def get_receive_funcs(speckle: SpeckleSceneSettings) -> tuple[ObjectCallback, ReceiveCompleteCallback]:
-    """
-    Fetches the injected callback functions from user specified "Receive Script"
-    """
-
-    objectCallback: ObjectCallback = None
-    receiveCompleteCallback: ReceiveCompleteCallback = None
-    
-    if speckle.receive_script in bpy.data.texts:
-        mod = bpy.data.texts[speckle.receive_script].as_module()
-        if hasattr(mod, "execute_for_each"):
-            objectCallback = mod.execute_for_each #type: ignore
-        elif hasattr(mod, "execute"): 
-            objectCallback = lambda c, o, _ : mod.execute(c.scene, o) #type: ignore
-
-        if hasattr(mod, "execute_for_all"):
-            receiveCompleteCallback = mod.execute_for_all #type: ignore
-
-    return (objectCallback, receiveCompleteCallback)
-
-#RECEIVE_MODES = [#TODO: modes
-#    ("create", "Create", "Add new geometry, without removing any existing objects"),
-#    ("replace", "Replace", "Replace objects from previous receive operations from the same stream"),
-#    #("update","Update", "") #TODO: update mode!
-#]
-
-INSTANCES_SETTINGS = [
-    ("collection_instance", "Collection Instance", "Receive Instances as Collection Instances"),
-    ("linked_duplicates", "Linked Duplicates", "Receive Instances as Linked Duplicates"),
-]
-
-class ReceiveStreamObjects(bpy.types.Operator):
-    """
-    Receive objects from selected model version
-    """
-
-    bl_idname = "speckle.receive_stream_objects"
-    bl_label = "Receive"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Receive objects from selected model version"
-
-    clean_meshes: BoolProperty(name="Clean Meshes", default=False) # type: ignore 
-
-    #receive_mode: EnumProperty(items=RECEIVE_MODES, name="Receive Type", default="replace", description="The behaviour of the receive operation")
-    receive_instances_as: EnumProperty(items=INSTANCES_SETTINGS, name="Receive Instances As", default="collection_instance", description="How to receive speckle Instances") # type: ignore 
-    
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "clean_meshes")
-        #col.prop(self, "receive_mode")
-        col.prop(self, "receive_instances_as")
-
-    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
-
-            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.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 # type: ignore 
-
-    def execute(self, context):
-        self.receive(context)
-        return {"FINISHED"}
-
-    def receive(self, context: Context) -> None:
-        bpy.context.view_layer.objects.active = None # type: ignore 
-
-        speckle = get_speckle(context)
-        
-        (user, stream, branch, commit) = speckle.validate_commit_selection()
-        
-        client = speckle_clients[int(speckle.active_user)]
-
-        transport = ServerTransport(stream.id, client)
-        
-        # Fetch commit data
-        commit_object = operations.receive(commit.referenced_object, transport)
-        client.commit.received(
-            stream.id,
-            commit.id,
-            source_application="blender",
-            message="Received model version from Speckle Blender",
-        )
-
-        metrics.track(
-            metrics.RECEIVE,
-            getattr(transport, "account", None), 
-            custom_props={
-                "sourceHostApp": host_applications.get_host_app_from_string(commit.source_application).slug,
-                "sourceHostAppVersion": commit.source_application,
-                "isMultiplayer": commit.author_id != user.id,
-                #"connector_version": "unknown", #TODO
-            },
-        )
-
-
-        # Convert received data
-        context.window_manager.progress_begin(0, commit_object.totalChildrenCount or 1)
-
-        set_convert_instances_as(self.receive_instances_as) #HACK: we need a better way to pass settings down to the converter
-
-        traversalFunc = get_default_traversal_func(can_convert_to_native)
-        converted_objects: Dict[str, Union[Object, Collection]] = {}
-        converted_count: int = 0
-        (object_converted_callback, on_complete_callback) = get_receive_funcs(speckle)
-
-        # older commits will have a non-collection root object
-        # for the sake of consistent behaviour, we will wrap any non-collection commit objects in a collection
-        if not isinstance(commit_object, SCollection):
-            dummy_commit_object = SCollection()
-            dummy_commit_object.elements = [commit_object]
-            dummy_commit_object.name = getattr(commit_object, "name", None)
-            dummy_commit_object.id = dummy_commit_object.get_id()
-            commit_object = dummy_commit_object
-
-        # ensure commit object has a name if not already
-        if not commit_object.name:
-            commit_object.name = f"{stream.name} [ {branch.name} @ {commit.id} ]" # Matches Rhino "Create" naming
-
-        for item in traversalFunc.traverse(commit_object):
-            
-            current: Base = item.current
-
-            if can_convert_to_native(current) or isinstance(current, SCollection):
-                try:
-                    if not current or not current.id:
-                        raise Exception(f"{current} was an invalid Speckle object")
-
-                    #Convert the object!
-                    converted_data_type: str
-                    converted: Union[Object, Collection, None]
-                    if isinstance(current, SCollection):
-                        if(current.collectionType == "Scene Collection"): raise ConversionSkippedException()
-                        converted = collection_to_native(current)
-                        converted_data_type = "COLLECTION"
-                    else:
-                        converted = convert_to_native(current)
-                        converted_data_type = "COLLECTION_INSTANCE" if converted.instance_collection else str(converted.type)
-                        
-                        #Run the user specified callback function (AKA receive script)
-                        if object_converted_callback:
-                            converted = object_converted_callback(context, converted, current)
-                    
-                    if converted is None:
-                        raise Exception("Conversion returned None")
-                        
-                    converted_objects[current.id] = converted
-
-                    add_to_hierarchy(converted, item, converted_objects, True)
-
-                    _report(f"Successfully converted {type(current).__name__} {current.id} as '{converted_data_type}'")
-                except ConversionSkippedException as ex:
-                    _report(f"Skipped converting {type(current).__name__} {current.id}: {ex}")
-                except Exception as ex:
-                    _report(f"Failed to converted {type(current).__name__} {current.id}: {ex}")
-
-            converted_count += 1
-            context.window_manager.progress_update(converted_count) #NOTE: We don't expect to ever reach 100% since not every object will be traversed
-
-
-        context.window_manager.progress_end()
-
-        if self.clean_meshes:
-            objects = {k: v for k, v in converted_objects.items() if isinstance(v, Object)}
-            self.clean_converted_meshes(context, objects)
-
-        if on_complete_callback:
-            on_complete_callback(context, converted_objects)
-
-
-
-class SendStreamObjects(bpy.types.Operator):
-    """
-    Send selected objects to selected model
-    """
-
-    bl_idname = "speckle.send_stream_objects"
-    bl_label = "Send"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Send selected objects to selected model"
-
-    apply_modifiers: BoolProperty(name="Apply modifiers", default=True) # type: ignore 
-    commit_message: StringProperty(
-        name="Message",
-        default="Sent elements from Blender.",
-    ) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "commit_message")
-        col.prop(self, "apply_modifiers")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) <= 0:
-            _report("No user accounts")
-            return {"CANCELLED"}
-        
-        N = len(context.selected_objects)
-        if N == 1:
-            self.commit_message = f"Sent {N} element from Blender."
-        else:
-            self.commit_message = f"Sent {N} elements from Blender."
-        return wm.invoke_props_dialog(self)
-
-
-    def execute(self, context):
-        self.send(context)
-        return {"FINISHED"}
-
-    def send(self, context: Context) -> None:
-
-        selected = context.selected_objects
-        if len(selected) < 1:
-            raise Exception("No objects are selected, sending canceled")
-
-        speckle = get_speckle(context)
-        (user, stream, branch) = speckle.validate_branch_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        units = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-
-        units_scale = context.scene.unit_settings.scale_length / get_scale_length(units)
-
-        # Get script from text editor for injection
-        func = None
-        if speckle.send_script in bpy.data.texts:
-            mod = bpy.data.texts[speckle.send_script].as_module()
-            if hasattr(mod, "execute"):
-                func = mod.execute #type: ignore
-
-        num_converted = 0
-        context.window_manager.progress_begin(0, max(len(selected), 1))
-
-        depsgraph = bpy.context.evaluated_depsgraph_get() if self.apply_modifiers else None
-
-        commit_builder = BlenderCommitObjectBuilder()
-        for obj in selected:
-            try:
-                # Run injected function
-                new_object = obj
-                if func:
-                    new_object = func(context.scene, obj)
-
-                    if (new_object is None):
-                        raise ConversionSkippedException(f"Script '{func.__module__}' returned None.")
-
-                converted = convert_to_speckle(
-                    obj,
-                    units_scale,
-                    units,
-                    depsgraph
-                )
-
-                if not converted:
-                    raise Exception("Converter returned None")
-
-                commit_builder.include_object(converted, obj)
-
-                _report(f"Successfully converted '{obj.name_full}' as '{converted.speckle_type}'")
-            except ConversionSkippedException as ex:
-                _report(f"Skipped converting '{obj.name_full}': '{ex}'")
-            except Exception as ex:
-                _report(f"Failed to converted '{obj.name_full}': '{ex}'")
-                
-            num_converted += 1
-            context.window_manager.progress_update(num_converted)
-
-        context.window_manager.progress_end()
-
-        commit_object = commit_builder.ensure_collection(context.scene.collection)
-        commit_builder.build_commit_object(commit_object)
-
-        metrics.track(
-            metrics.SEND,
-            client.account, 
-            custom_props={
-                "branches": len(stream.branches),
-                #"collaborators": 0, #TODO: 
-                "isMain": branch.name == "main",
-            },
-        )
-    
-        _report(f"Sending data to {stream.name}")
-        transport = ServerTransport(stream.id, client)
-        OBJECT_ID = operations.send(
-            commit_object,
-            [transport],
-        )
-
-        COMMIT_ID = client.commit.create(
-            stream.id,
-            OBJECT_ID,
-            branch.name,
-            message=self.commit_message,
-            source_application="blender",
-        )
-
-        if client.account.serverInfo.frontend2:
-            sent_url = f"{user.server_url}/projects/{stream.id}/models/{branch.id}@{COMMIT_ID}"
-        else:
-            sent_url = f"{user.server_url}/streams/{stream.id}/commits/{COMMIT_ID}"
-
-        _report(f"Commit Created {sent_url}")
-
-        selection_state.selected_commit_id = COMMIT_ID
-        selection_state.selected_branch_id = branch.id
-        selection_state.selected_stream_id = stream.id
-        selection_state.selected_user_id = user.id
-
-        bpy.ops.speckle.load_user_streams() # refresh loaded commits
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-
-
-
-class ViewStreamDataApi(bpy.types.Operator):
-    bl_idname = "speckle.view_stream_data_api"
-    bl_label = "Open Model in Web"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "View the selected model in the web browser"
-
-    def execute(self, context):
-        self.view_stream_data_api(context)
-        return {"FINISHED"}
-
-    def view_stream_data_api(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        url = self._get_url_from_selection(speckle)
-
-        _report(f"Opening {url} in web browser")
-        
-        if not webbrowser.open(url, new=2):
-            raise Exception(f"Failed to open model in browser ({url})")
-        
-        metrics.track(
-            "Connector Action",
-            None, 
-            custom_props={
-                "name": "view_stream_data_api"
-            },
-        )
-
-    @staticmethod
-    def _get_url_from_selection(speckleScene : SpeckleSceneSettings) -> str:
-
-        client = speckle_clients[int(speckleScene.active_user)]
-        (user, stream) = speckleScene.validate_stream_selection()
-        branch = stream.get_active_branch()
-        commit = branch.get_active_commit() if branch else None
-
-        if client.account.serverInfo.frontend2:
-            server_url = f"{user.server_url}/projects/{stream.id}/"
-            if branch:
-                server_url += f"models/{branch.id}"
-            if commit:
-                server_url += f"@{commit.id}"
-        else:
-            server_url = f"{user.server_url}/streams/{stream.id}/"
-            if commit:
-                server_url += f"commits/{commit.id}"
-            elif branch:
-                server_url += f"branches/{branch.name}"
-
-        return server_url
-    
-class AddStreamFromURL(bpy.types.Operator):
-    """
-    Add / select an existing project by providing its URL
-    """
-
-    bl_idname = "speckle.add_stream_from_url"
-    bl_label = "Add Project From URL"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Add / select an existing project by providing its URL"
-    stream_url: StringProperty(
-        name="Project URL", default=""
-    ) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "stream_url")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        self.add_stream_from_url(context)
-        return {"FINISHED"}
-
-    @staticmethod
-    def _get_or_add_stream(user : SpeckleUserObject, stream : Stream) -> Tuple[int, SpeckleStreamObject]:
-        index, b_stream = next(
-            ((i, cast(SpeckleStreamObject, s)) for i, s in enumerate(user.streams) if s.id == stream.id),
-            (None, None),
-        )
-
-        if index is not None:
-            assert(b_stream)
-            return (index, b_stream)
-        
-        add_user_stream(user, stream)
-        return next(
-            (i, cast(SpeckleStreamObject, s)) for i, s in enumerate(user.streams) if s.id == stream.id
-        )
-            
-
-    def add_stream_from_url(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        wrapper = StreamWrapper(self.stream_url)
-        user_index = next(
-            (i for i, u in enumerate(speckle.users) if wrapper.host in u.server_url),
-            None,
-        )
-        if user_index is None:
-            raise Exception(f"No user account credentials for {wrapper.host}, have you added your account in Manager?")
-        
-        speckle.active_user = str(user_index)
-        user = cast(SpeckleUserObject, speckle.users[user_index])
-
-        client = speckle_clients[user_index]
-        stream = client.stream.get(wrapper.stream_id, branch_limit=LoadUserStreams.branch_limit, commit_limit=LoadUserStreams.commits_limit)
-        if not isinstance(stream, Stream):
-            raise SpeckleException(f"Could not get the requested project {wrapper.stream_id}")
-
-        (index, b_stream) = self._get_or_add_stream(user, stream)
-        user.active_stream = index
-
-        _report(f"Selecting project at index {index} ({b_stream.id} - {b_stream.name})")
-
-        if wrapper.branch_name:
-            b_index = b_stream.branches.find(wrapper.branch_name)
-            b_stream.branch = str(b_index if b_index != -1 else 0)
-        elif wrapper.commit_id:
-            commit = client.commit.get(wrapper.stream_id, wrapper.commit_id)
-            if isinstance(commit, Commit):
-                b_index = b_stream.branches.find(commit.branchName)
-                if b_index == -1:
-                    b_index = 0
-                b_stream.branch = str(b_index)
-                c_index = b_stream.branches[b_index].commits.find(commit.id)
-                b_stream.branches[b_index].commit = str(c_index if c_index != -1 else 0)
-
-        # Update view layer
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "add_stream_from_url"
-            },
-        )
-
-
-class CreateStream(bpy.types.Operator):
-    """
-    Create a new Speckle project using the selected user account
-    """
-
-    bl_idname = "speckle.create_stream"
-    bl_label = "Create Project"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Create a new Speckle project using the selected user account"
-
-    stream_name: StringProperty(name="Project name") # type: ignore 
-    stream_description: StringProperty(
-        name="Project description", default="My new project"
-    ) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "stream_name")
-        col.prop(self, "stream_description")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        self.create_stream(context)
-        return {"FINISHED"}
-        
-    def create_stream(self, context: Context) -> None:
-        speckle = get_speckle(context)
-
-        user = speckle.validate_user_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        client.stream.create(
-            name=self.stream_name, 
-            description=self.stream_description, 
-            is_public=True
-        )
-
-        bpy.ops.speckle.load_user_streams()
-        user.active_stream = user.streams.find(self.stream_name)
-
-        # Update view layer
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "create_stream"
-            },
-        )
-
-
-@deprecated
-class DeleteStream(bpy.types.Operator):
-    """
-    Permanently delete the selected project
-    """
-
-    bl_idname = "speckle.delete_stream"
-    bl_label = "Delete Project"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Permanently delete the selected project"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        description="⚠ This action will delete your entire stream permanently ⚠",
-        default=False,
-    ) # type: ignore 
-
-    delete_collection: BoolProperty(name="Delete collection", default=False) # type: ignore 
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-        col.prop(self, "delete_collection")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        speckle = get_speckle(context)
-        if len(speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        if not self.are_you_sure:
-            _report(f"Cancelled by user - are_you_sure was {self.are_you_sure}")
-            return {"CANCELLED"}
-        self.are_you_sure = False
-
-        self.delete_stream(context, self.delete_collection)
-        return {"FINISHED"}
-
-    @staticmethod
-    def delete_stream(context: Context, delete_collection: bool) -> None:
-        speckle = get_speckle(context)
-        (_, stream) = speckle.validate_stream_selection()
-
-        client = speckle_clients[int(speckle.active_user)]
-
-        client.stream.delete(id=stream.id)
-
-        if delete_collection:
-            # This may not work anymore since we changed the collection naming...
-            col_name = "SpeckleStream_{}_{}".format(stream.name, stream.id)
-            if col_name in bpy.data.collections:
-                collection = bpy.data.collections[col_name]
-                bpy.data.collections.remove(collection)
-
-        bpy.ops.speckle.load_user_streams()
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "delete_stream"
-            },
-        )
-
-@deprecated
-class SelectOrphanObjects(bpy.types.Operator):
-    """
-    Select Speckle objects that don't belong to any stream
-    """
-
-    bl_idname = "speckle.select_orphans"
-    bl_label = "Select Orphaned Objects (DEPRECATED)"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Select Speckle objects that don't belong to any stream"
-
-    def draw(self, context):
-        layout = self.layout
-
-    def execute(self, context):
-
-        for o in context.scene.objects:
-            if (
-                o.speckle.stream_id
-                and o.speckle.stream_id not in context.scene["speckle_streams"]
-            ):
-                o.select = True
-            else:
-                o.select = False
-
-        metrics.track(
-            "Connector Action", 
-            custom_props={
-                "name": "SelectOrphanObjects"
-            },
-        )
-
-        return {"FINISHED"}
-
-class CopyStreamId(bpy.types.Operator):
-    """
-    Copy the selected project id to clipboard
-    """
-
-    bl_idname = "speckle.stream_copy_id"
-    bl_label = "Copy Project Id"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy the selected project id to clipboard"
-
-    def execute(self, context):
-        self.copy_stream_id(context)
-        return {"FINISHED"}
-        
-    def copy_stream_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, stream) = speckle.validate_stream_selection()
-        bpy.context.window_manager.clipboard = stream.id
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_stream_id"
-            },
-        )
-
-class CopyCommitId(bpy.types.Operator):
-    """
-    Copy the selected version id to clipboard
-    """
-
-    bl_idname = "speckle.commit_copy_id"
-    bl_label = "Copy Version Id"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy the selected version id to clipboard"
-
-    def execute(self, context):
-        self.copy_commit_id(context)
-        return {"FINISHED"}
-
-        
-    def copy_commit_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, _, _, commit) = speckle.validate_commit_selection()
-        bpy.context.window_manager.clipboard = commit.id
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_commit_id"
-            },
-        )
-
-
-
-class CopyModelId(bpy.types.Operator):
-    """
-    Copy model id to clipboard
-    """
-
-    bl_idname = "speckle.model_copy_id"
-    bl_label = "Copy model id"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy model id to clipboard"
-
-    def execute(self, context):
-        self.copy_model_id(context)
-        return {"FINISHED"}
-
-        
-    def copy_model_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, _, branch) = speckle.validate_branch_selection()
-
-        bpy.context.window_manager.clipboard = branch.id
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_branch_id"
-            },
-        )
-
-@deprecated
-class CopyBranchName(bpy.types.Operator):
-    """
-    Copy branch name to clipboard
-    """
-
-    bl_idname = "speckle.branch_copy_name"
-    bl_label = "Copy branch name"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy branch name to clipboard"
-
-    def execute(self, context):
-        self.copy_branch_id(context)
-        return {"FINISHED"}
-
-        
-    def copy_branch_id(self, context) -> None:
-        speckle = get_speckle(context)
-
-        (_, _, branch) = speckle.validate_branch_selection()
-
-        bpy.context.window_manager.clipboard = branch.name
-
-        metrics.track(
-            "Connector Action",
-            custom_props={
-                "name": "copy_branch_id"
-            },
-        )
-
-@deprecated
-class SelectOrphanObjects(bpy.types.Operator):
-    """
-    Select Speckle objects that don't belong to any stream
-    """
-
-    bl_idname = "speckle.select_orphans"
-    bl_label = "Select orphaned objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Select Speckle objects that don't belong to any stream"
-
-    def draw(self, context):
-        layout = self.layout
-
-    def execute(self, context):
-
-        for o in context.scene.objects:
-            if (
-                o.speckle.stream_id
-                and o.speckle.stream_id not in context.scene["speckle_streams"]
-            ):
-                o.select = True
-            else:
-                o.select = False
-
-        metrics.track(
-            "Connector Action", 
-            custom_props={
-                "name": "SelectOrphanObjects"
-            },
-        )
-
-        return {"FINISHED"}

bpy_speckle/operators/users.py

@@ -1,211 +0,0 @@
-"""
-User account operators
-"""
-from typing import List, cast
-import bpy
-from bpy.types import Context
-from bpy_speckle.functions import _report
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.properties.scene import SpeckleBranchObject, SpeckleCommitObject, SpeckleSceneSettings, SpeckleStreamObject, SpeckleUserObject, get_speckle, restore_selection_state
-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):
-    """
-    Loads all user accounts from the credentials in the local database.
-    See docs to add accounts via Manager
-    """
-
-    bl_idname = "speckle.users_load"
-    bl_label = "Load Users"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Loads all user accounts from the credentials in the local database.\nSee docs to add accounts via Manager"
-
-    def execute(self, context):
-
-        _report("Loading users...")
-
-        speckle = get_speckle(context)
-        users_list = speckle.users
-
-        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:
-            try:
-                add_user_account(profile, speckle)
-            except Exception as ex:
-                _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)
-
-        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
-
-    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
-
-    _report(f"Adding stream {s.id} - {s.name}")
-    
-    if stream.branches:
-        s.load_stream_branches(stream)
-
-
-class LoadUserStreams(bpy.types.Operator):
-    """
-    (Re)Load all available projects for active user
-    """
-
-    bl_idname = "speckle.load_user_streams"
-    bl_label = "Load User's Projects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "(Re)Load all available projects for active user"
-
-    stream_limit: int = 20
-    branch_limit: int = 100
-    commits_limit: int = 10
-
-    def execute(self, context):
-        self.load_user_stream(context)
-        return {"FINISHED"}
-
-        
-    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 projects") from ex
-        
-        if not streams:
-            _report("Zero projects found")
-            return
-
-
-        active_stream_id = None
-        if active_stream := user.get_active_stream():
-            active_stream_id = active_stream.id
-        elif len(user.streams) > 0:
-            active_stream_id = user.streams[0].id
-
-        user.streams.clear()
-
-        for i, s in enumerate(streams):
-            assert(s.id)
-            load_branches = s.id == active_stream_id if active_stream_id else i == 0
-            if load_branches:
-                sstream = client.stream.get(id=s.id, branch_limit=self.branch_limit, commit_limit=10)
-                add_user_stream(user, sstream)
-            else:
-                add_user_stream(user, s)
-
-        restore_selection_state(speckle)
-
-        bpy.context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-                
-        metrics.track(
-            "Connector Action",
-            client.account, 
-            custom_props={
-                "name": "LoadUserStreams"
-            },
-        )
-
-

bpy_speckle/properties/__init__.py

@@ -1,23 +0,0 @@
-from .scene import (
-    SpeckleSceneSettings,
-    SpeckleSceneObject,
-    SpeckleUserObject,
-    SpeckleStreamObject,
-    SpeckleBranchObject,
-    SpeckleCommitObject,
-)
-from .object import SpeckleObjectSettings
-from .collection import SpeckleCollectionSettings
-from .addon import SpeckleAddonPreferences
-
-property_classes = [
-    SpeckleSceneObject,
-    SpeckleCommitObject,
-    SpeckleBranchObject,
-    SpeckleStreamObject,
-    SpeckleUserObject,
-    SpeckleSceneSettings,
-    SpeckleObjectSettings,
-    SpeckleCollectionSettings,
-    SpeckleAddonPreferences,
-]

bpy_speckle/properties/addon.py

@@ -1,17 +0,0 @@
-"""
-Addon properties
-"""
-import bpy
-
-
-class SpeckleAddonPreferences(bpy.types.AddonPreferences):
-    """
-    Add-on preferences
-    TODO: add any preferences that might be relevant here
-    """
-
-    bl_idname = __package__
-
-    def draw(self, context):
-        layout = self.layout
-        layout.label(text="SpeckleBlender preferences")

bpy_speckle/properties/collection.py

@@ -1,18 +0,0 @@
-"""
-Collection properties
-"""
-import bpy
-
-
-class SpeckleCollectionSettings(bpy.types.PropertyGroup):
-    enabled: bpy.props.BoolProperty(default=False, name="Enabled") # type: ignore
-
-    send_or_receive: bpy.props.EnumProperty(
-        name="Mode",
-        items=(
-            ("send", "Send", "Send data to Speckle server."),
-            ("receive", "Receive", "Receive data from Speckle server."),
-        ),
-    ) # type: ignore
-    stream_id: bpy.props.StringProperty(default="") # type: ignore
-    name: bpy.props.StringProperty(default="") # type: ignore

bpy_speckle/properties/object.py

@@ -1,18 +0,0 @@
-"""
-Object properties
-"""
-import bpy
-
-
-class SpeckleObjectSettings(bpy.types.PropertyGroup):
-    enabled: bpy.props.BoolProperty(default=False, name="Enabled")
-
-    send_or_receive: bpy.props.EnumProperty(
-        name="Mode",
-        items=(
-            ("send", "Send", "Send data to Speckle server."),
-            ("receive", "Receive", "Receive data from Speckle server."),
-        ),
-    ) # type: ignore
-    stream_id: bpy.props.StringProperty(default="") # type: ignore
-    object_id: bpy.props.StringProperty(default="") # type: ignore

bpy_speckle/properties/scene.py

@@ -1,311 +0,0 @@
-"""
-Scene properties
-"""
-from typing import Iterable, Optional, Tuple, Union, cast
-from dataclasses import dataclass
-import bpy
-from bpy.props import (
-    StringProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-    IntProperty,
-)
-
-from bpy_speckle.clients import speckle_clients
-from specklepy.core.api.models import Stream
-
-class SpeckleSceneObject(bpy.types.PropertyGroup):
-    name: bpy.props.StringProperty(default="") # type: ignore
-
-
-class SpeckleCommitObject(bpy.types.PropertyGroup):
-    id: StringProperty(default="") # type: ignore
-    message: StringProperty(default="") # type: ignore
-    author_name: StringProperty(default="") # type: ignore
-    author_id: StringProperty(default="") # type: ignore
-    created_at: StringProperty(default="") # type: ignore
-    source_application: StringProperty(default="") # type: ignore
-    referenced_object: StringProperty(default="") # type: ignore
-
-
-class SpeckleBranchObject(bpy.types.PropertyGroup):
-    def get_commits(self, context):
-        if self.commits != None and len(self.commits) > 0:
-            COMMITS = cast(Iterable[SpeckleCommitObject], self.commits)
-            return [
-                (str(i), commit.id, commit.message, i)
-                for i, commit in enumerate(COMMITS)
-            ]
-        return [("0", "<none>", "<none>", 0)]
-  
-    def commit_update_hook(self, context: bpy.types.Context):
-        selection_state.selected_commit_id = SelectionState.get_item_id_by_index(self.commits, self.commit)
-        selection_state.selected_branch_id = self.id
-        # print(f"commit_update_hook: {selection_state.selected_commit_id=}, {selection_state.selected_branch_id=}")
-
-    name: StringProperty(default="main") # type: ignore
-    id: StringProperty(default="") # type: ignore
-    description: StringProperty(default="") # type: ignore
-    commits: CollectionProperty(type=SpeckleCommitObject) # type: ignore
-    commit: EnumProperty(
-        name="Version",
-        description="Selected model version",
-        items=get_commits,
-        update=commit_update_hook,
-    ) # type: ignore
-    
-    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):
-    def load_stream_branches(self, sstream: Stream):
-        self.branches.clear()
-        # branches = [branch for branch in stream.branches.items if branch.name != "globals"]
-        for b in sstream.branches.items:
-            branch = cast(SpeckleBranchObject, self.branches.add())
-            branch.name = b.name
-            branch.id = b.id
-            branch.description = b.description or ""
-
-            if not b.commits:
-                continue
-
-            for c in b.commits.items:
-                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.strftime("%Y-%m-%d %H:%M:%S.%f%Z") if c.createdAt else ""
-                commit.source_application = str(c.sourceApplication)
-                commit.referenced_object = c.referencedObject
-
-    def get_branches(self, context):
-        if self.branches:
-            BRANCHES = cast(Iterable[SpeckleBranchObject], self.branches)
-            return [
-                (str(i), branch.name, branch.description, i)
-                for i, branch in enumerate(BRANCHES)
-                if branch.name != "globals"
-            ]
-        return [("0", "<none>", "<none>", 0)]
-    
-    def branch_update_hook(self, context: bpy.types.Context):
-        selection_state.selected_branch_id = SelectionState.get_item_id_by_index(self.branches, self.branch)
-        # print(f"branch_update_hook: {selection_state.selected_branch_id=}, {selection_state.selected_stream_id=}")
-
-    name: StringProperty(default="") # type: ignore
-    description: StringProperty(default="") # type: ignore
-    id: StringProperty(default="") # type: ignore
-    branches: CollectionProperty(type=SpeckleBranchObject) # type: ignore
-    branch: EnumProperty(
-        name="Model",
-        description="Selected Model",
-        items=get_branches,
-        update=branch_update_hook,
-    ) # type: ignore
-
-    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):
-    def fetch_stream_branches(self, context: bpy.types.Context, stream: SpeckleStreamObject):
-        speckle = context.scene.speckle
-        client = speckle_clients[int(speckle.active_user)]
-        sstream = client.stream.get(id=stream.id, branch_limit=100, commit_limit=10) # TODO: refactor magic numbers
-        stream.load_stream_branches(sstream)
-
-    def stream_update_hook(self, context: bpy.types.Context):
-        stream = SelectionState.get_item_by_index(self.streams, self.active_stream)
-        selection_state.selected_stream_id = stream.id
-        # print(f"stream_update_hook: {selection_state.selected_stream_id=}, {selection_state.selected_user_id=}")
-        if len(stream.branches) == 0: # do not reload on selection, same as the old behavior 
-            self.fetch_stream_branches(context, stream)
-
-    server_name: StringProperty(default="SpeckleXYZ") # type: ignore
-    server_url: StringProperty(default="https://speckle.xyz") # type: ignore
-    id: StringProperty(default="") # type: ignore
-    name: StringProperty(default="Speckle User") # type: ignore
-    email: StringProperty(default="user@speckle.xyz") # type: ignore
-    company: StringProperty(default="SpeckleSystems") # type: ignore
-    streams: CollectionProperty(type=SpeckleStreamObject) # type: ignore
-    active_stream: IntProperty(default=0, update=stream_update_hook) # type: ignore
-
-    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):
-        return [
-            ("<none>", "<none>", "<none>"),
-            *[(t.name, t.name, t.name) for t in bpy.data.texts],
-        ]
-
-    streams: EnumProperty(
-        name="Available streams",
-        description="Available streams associated with user.",
-        items=[],
-    ) # type: ignore
-
-    users: CollectionProperty(type=SpeckleUserObject) # type: ignore
-
-    def get_users(self, context):
-        USERS = cast(Iterable[SpeckleUserObject], self.users)
-        return [
-            (str(i), f"{user.email} ({user.server_name})", user.server_url, i)
-            for i, user in enumerate(USERS)
-        ]
-
-    def user_update_hook(self, context):
-        bpy.ops.speckle.load_user_streams() # type: ignore
-        selection_state.selected_user_id = SelectionState.get_item_id_by_index(self.users, self.active_user)
-
-    active_user: EnumProperty(
-        items=get_users,
-        name="Account",
-        description="Select account",
-        update=user_update_hook,
-        get=None,
-        set=None,
-    ) # type: ignore
-
-    objects: CollectionProperty(type=SpeckleSceneObject) # type: ignore
-
-    scale: FloatProperty(default=0.001) # type: ignore
-
-    user: StringProperty(
-        name="User",
-        description="Current user",
-        default="Speckle User",
-    ) # type: ignore
-
-    receive_script: EnumProperty(
-        name="Receive script",
-        description="Custom py script to execute when receiving objects. See docs for function signature.",
-        items=get_scripts,
-    ) # type: ignore
-
-    send_script: EnumProperty(
-        name="Send script",
-        description="Custom py script to execute when sending objects. See docs for function signature",
-        items=get_scripts,
-    ) # type: ignore
-
-    def get_active_user(self) -> Optional[SpeckleUserObject]:
-        if self.active_user is None:
-            return None
-        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 account 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 project 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 model 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 model version selected/found")
-        
-        return (user, stream, branch, commit)
-    
-class SelectionException(Exception):
-    pass
-
-def get_speckle(context: bpy.types.Context) -> SpeckleSceneSettings:
-    """
-    Gets the speckle scene object
-    """
-    return context.scene.speckle #type: ignore
-
-@dataclass
-class SelectionState:
-    selected_user_id : Optional[str] = None
-    selected_stream_id : Optional[str] = None
-    selected_branch_id : Optional[str] = None
-    selected_commit_id : Optional[str] = None
-
-    @staticmethod
-    def get_item_id_by_index(collection: bpy.types.PropertyGroup, index: Union[str, int]) -> Optional[str]:
-        if item := SelectionState.get_item_by_index(collection, index):
-            return item.id
-        return None
-    
-    @staticmethod
-    def get_item_by_index(collection: bpy.types.PropertyGroup, index: Union[str, int]) -> Optional[bpy.types.PropertyGroup]:
-        items = collection.values()
-        i = int(index)
-        if 0 <= i <= len(items):
-            return items[i]
-        return None
-    
-    @staticmethod
-    def get_item_index_by_id(collection: Iterable[SpeckleCommitObject], id: Optional[str]) -> Optional[str]:
-        for index, item in enumerate(collection):
-            if item.id == id:
-                return str(index)
-        return None
-
-selection_state = SelectionState()
-
-def restore_selection_state(speckle: SpeckleSceneSettings) -> None:
-    # Restore branch selection state
-    if selection_state.selected_branch_id != None:
-        (active_user, active_stream) = speckle.validate_stream_selection()
-        # print(f"restore_selection_state: {active_user.id=}, {active_stream.id=}")
-        # print(f"restore_selection_state: {selection_state.selected_user_id=}, {selection_state.selected_stream_id=}, {selection_state.selected_branch_id=}, {selection_state.selected_commit_id=}")
-
-        is_same_user = active_user.id == selection_state.selected_user_id
-    
-        if is_same_user:
-            active_user.active_stream = int(SelectionState.get_item_index_by_id(active_user.streams, selection_state.selected_stream_id))
-            active_stream = SelectionState.get_item_by_index(active_user.streams, active_user.active_stream)
-            if branch := SelectionState.get_item_index_by_id(active_stream.branches, selection_state.selected_branch_id):
-                active_stream.branch = branch
-    
-    # Restore commit selection state
-    if selection_state.selected_commit_id != None:
-        (active_user, active_stream, active_branch) = speckle.validate_branch_selection()
-        # print(f"restore_selection_state: {active_user.id=}, {active_stream.id=}, {active_branch.id=}")
-        # print(f"restore_selection_state: {selection_state.selected_user_id=}, {selection_state.selected_stream_id=}, {selection_state.selected_branch_id=}, {selection_state.selected_commit_id=}")
-
-        is_same_user = active_user.id == selection_state.selected_user_id
-        is_same_stream = active_stream.id == selection_state.selected_stream_id
-        is_same_branch = active_branch.id == selection_state.selected_branch_id
-
-        if is_same_user and is_same_stream and is_same_branch:
-            if commit := SelectionState.get_item_index_by_id(active_branch.commits, selection_state.selected_commit_id):
-                active_branch.commit = commit

bpy_speckle/ui/__init__.py

@@ -1,18 +0,0 @@
-from .object import OBJECT_PT_speckle
-from .view3d import (
-    VIEW3D_UL_SpeckleUsers,
-    VIEW3D_UL_SpeckleStreams,
-    VIEW3D_PT_SpeckleUser,
-    VIEW3D_PT_SpeckleStreams,
-    VIEW3D_PT_SpeckleActiveStream,
-    VIEW3D_PT_SpeckleHelp,
-)
-
-ui_classes = [
-    VIEW3D_PT_SpeckleUser,
-    VIEW3D_PT_SpeckleStreams,
-    VIEW3D_PT_SpeckleActiveStream,
-    VIEW3D_UL_SpeckleUsers,
-    VIEW3D_UL_SpeckleStreams,
-    VIEW3D_PT_SpeckleHelp,
-]

bpy_speckle/ui/object.py

@@ -1,36 +0,0 @@
-"""
-Object UI elements
-"""
-
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-from deprecated import deprecated
-
-@deprecated
-class OBJECT_PT_speckle(bpy.types.Panel):
-    bl_space_type = "PROPERTIES"
-    # bl_idname = 'OBJECT_PT_speckle'
-    bl_region_type = "WINDOW"
-    bl_context = "object"
-    bl_label = "Speckle"
-
-    def draw_header(self, context):
-        self.layout.prop(context.object.speckle, "enabled", text="")
-
-    def draw(self, context):
-        ob = context.object
-        layout = self.layout
-        layout.active = ob.speckle.enabled
-        col = layout.column()
-        col.prop(ob.speckle, "send_or_receive", expand=True)
-        col.prop(ob.speckle, "stream_id", text="Project ID")
-        col.prop(ob.speckle, "object_id", text="Object ID")
-        col.operator("speckle.update_object", text="Update")
-        col.operator("speckle.reset_object", text="Reset")
-        col.operator("speckle.delete_object", text="Delete")

bpy_speckle/ui/view3d.py

@@ -1,260 +0,0 @@
-"""
-Speckle UI elements for the 3d viewport
-"""
-
-
-import bpy
-
-from datetime import datetime
-
-from bpy_speckle.properties.scene import get_speckle
-
-Region = "TOOLS" if bpy.app.version < (2, 80, 0) else "UI"
-
-
-def wrap(width, text):
-    """
-    Split strings into width for
-    wrapping
-    """
-    lines = []
-
-    arr = text.split()
-    lengthSum = 0
-
-    line = []
-    for var in arr:
-        lengthSum += len(var) + 1
-        if lengthSum <= width:
-            line.append(var)
-        else:
-            lines.append(" ".join(line))
-            line = [var]
-            lengthSum = len(var)
-
-    lines.append(" ".join(line))
-
-    return lines
-
-
-def get_available_users(self, context):
-    """
-    Function to populate users list
-    """
-    return [(a, a, a.name) for a in context.scene.speckle.users]
-
-
-class VIEW3D_UL_SpeckleUsers(bpy.types.UIList):
-    """
-    Speckle user list
-    """
-
-    def draw_item(self, context, layout, data, user, active_data, active_propname):
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            if user:
-                # layout.prop(user, "name", text=user.name, emboss=False, icon_value=0)
-                layout.label(
-                    text=user.name + " (" + user.email + ")",
-                    translate=False,
-                    icon_value=0,
-                )
-            else:
-                layout.label(text="", translate=False, icon_value=0)
-
-        elif self.layout_type in {"GRID"}:
-            layout.alignment = "CENTER"
-            layout.label(text="Users", icon_value=0)
-
-
-class VIEW3D_UL_SpeckleStreams(bpy.types.UIList):
-    """
-    Speckle projects list
-    """
-
-    def draw_item(self, context, layout, data, stream, active_data, active_propname):
-        if self.layout_type in {"DEFAULT", "COMPACT"}:
-            if stream:
-                layout.label(
-                    text=f"{stream.name} ({stream.id})",
-                    translate=False,
-                    icon_value=0,
-                )
-            else:
-                layout.label(text=" ", translate=False, icon_value=0)
-
-        elif self.layout_type in {"GRID"}:
-            layout.alignment = "CENTER"
-            layout.label(text="Projects", icon_value=0)
-
-
-class VIEW3D_PT_SpeckleUser(bpy.types.Panel):
-    """
-    Speckle Users UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "User Account"
-
-    def draw(self, context):
-        speckle = get_speckle(context)
-
-        layout = self.layout
-        col = layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="Refresh to initialise")
-        else:
-            col.prop(speckle, "active_user", text="")
-            user = speckle.users[int(speckle.active_user)]
-            col.label(text=f"{user.server_name} ({user.server_url})")
-            col.label(text=f"{user.name} ({user.email})")
-
-        col.operator("speckle.users_load", text="", icon="FILE_REFRESH")
-
-class VIEW3D_PT_SpeckleStreams(bpy.types.Panel):
-    """
-    Speckle projects UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Projects"
-
-    def draw(self, context):
-        speckle = get_speckle(context)
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No Projects")
-        else:
-            user = speckle.users[int(speckle.active_user)]
-            col.template_list(
-                "VIEW3D_UL_SpeckleStreams", "", user, "streams", user, "active_stream"
-            )
-            row = col.row(align=True)
-            row.operator("speckle.add_stream_from_url", text="", icon="URL")
-            row.operator("speckle.create_stream", text="", icon="ADD")
-            row.operator("speckle.load_user_streams", text="", icon="FILE_REFRESH")
-
-
-class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):
-    """
-    Speckle Active Projects UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Active Project"
-
-    def draw(self, context):
-        speckle = get_speckle(context)
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No projects")
-        else:
-            user = speckle.validate_user_selection()
-            #user = speckle.users[int(speckle.active_user)]
-            if len(user.streams) < 1:
-                col.label(text="No active project")
-            else:
-                stream = user.streams[user.active_stream]
-                # user.active_stream = min(user.active_stream, len(user.streams) - 1)
-                row = col.row()
-                row.label(text=f"{stream.name} ({stream.id})")
-                row.operator("speckle.stream_copy_id", text="", icon="COPY_ID")
-                col.separator()
-
-                row = col.row()
-                row.prop(stream, "branch", text="Model")
-                row.operator("speckle.model_copy_id", text="", icon="COPY_ID")
-
-                if len(stream.branches) > 0:
-                    branch = stream.branches[int(stream.branch)]
-
-                    row = col.row()
-                    row.prop(branch, "commit", text="Version")
-                    row.operator("speckle.commit_copy_id", text="", icon="COPY_ID")
-
-                    if len(branch.commits) > 0:
-                        commit = branch.commits[int(branch.commit)]
-                        area = col.box()
-                        area.separator()
-
-                        lines = wrap(32, commit.message)
-                        for line in lines:
-                            row = area.row(align=True)
-                            row.alignment = "EXPAND"
-                            row.scale_y = 0.4
-                            row.label(text=line)
-                        area.separator()
-
-                        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 models found!")
-
-                col.separator()
-
-                area = col.box()
-                row = area.row()
-                subcol = row.column()
-                subcol.operator("speckle.receive_stream_objects", text="Receive")
-                subcol.prop(speckle, "receive_script", text="")
-                subcol = row.column()
-                subcol.operator("speckle.send_stream_objects", text="Send")
-                subcol.prop(speckle, "send_script", text="")
-
-                col.separator()
-
-                row = col.row(align=True)
-                subcol = row.column()
-
-                col.label(text="Description:")
-                area = col.box()
-                area.separator()
-
-                lines = wrap(32, stream.description)
-
-                for line in lines:
-                    row = area.row(align=True)
-                    row.alignment = "EXPAND"
-                    row.scale_y = 0.4
-                    row.label(text=line)
-
-                area.separator()
-                col.separator()
-                col.operator("speckle.view_stream_data_api", text="Open Model in Web")
-
-
-class VIEW3D_PT_SpeckleHelp(bpy.types.Panel):
-    """
-    Speckle Help UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Help"
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-
-        col.operator("speckle.open_speckle_guide")
-        col.separator()
-        col.operator("speckle.open_speckle_tutorials")
-        col.separator()
-        col.operator("speckle.open_speckle_forum")

bpy_speckle/util.py

@@ -1,54 +0,0 @@
-def find_key_case_insensitive(data, key, default=None):
-    value = data.get(key)
-    if value:
-        return value
-
-    """
-    Necessary to find keys where the first character
-    is capitalized
-    """
-    value = data.get(key[0].upper() + key[1:])
-    if value:
-        return value
-
-    value = data.get(key.upper())
-    if value:
-        return value
-
-    return default
-
-
-def get_iddata(base, uuid, name, obdata):
-    """
-    This is taken from the import_3dm add-on:
-    https://github.com/jesterKing/import_3dm
-    # Copyright (c) 2018-2019 Nathan Letwory, Joel Putnam, 
-    Tom Svilans
-
-    Get an iddata. If an object with given uuid is found in
-    this .blend use that. Otherwise new up one with base.new,
-    potentially with obdata if that is set
-    """
-    founditem = None
-    if uuid is not None:
-        for item in base:
-            if item.get("speckle_id", None) == str(uuid):
-                founditem = item
-                break
-    elif name:
-        for item in base:
-            if item.get("name", None) == name:
-                founditem = item
-                break
-    if founditem:
-        theitem = founditem
-        theitem["name"] = name
-        if obdata:
-            theitem.data = obdata
-    else:
-        if obdata:
-            theitem = base.new(name=name, object_data=obdata)
-        else:
-            theitem = base.new(name=name)
-        tag_data(theitem, uuid, name)
-    return theitem

export_dependencies.sh

@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 set -e -o pipefail
 
-poetry export --only main -o bpy_speckle/requirements.txt
+uv pip compile pyproject.toml --output-file bpy_speckle/requirements.txt --all-extras

patch_installer.py

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

patch_version.py

@@ -1,21 +1,36 @@
 import re
 import sys
 
-def patch_connector(tag):
-    """Patches the connector version within the connector init file"""
-    bpy_file = "bpy_speckle/__init__.py"
-    tag = tag.split(".")
+def patch_addon(simple_version: str):
+    """Patches the __init__.py bl_info version within the connector init file"""
+    FILE_PATH = "bpy_speckle/__init__.py"
+    version = simple_version.split(".")
 
-    with open(bpy_file, "r") as file:
+    with open(FILE_PATH, "r") as file:
         lines = file.readlines()
 
         for (index, line) in enumerate(lines):
             if '"version":' in line:
-                lines[index] = f'    "version": ({tag[0]}, {tag[1]}, {tag[2]}),\n'
-                print(f"Patched connector version number in {bpy_file}")
+                lines[index] = f'    "version": ({version[0]}, {version[1]}, {version[2]}),\n'
+
+        with open(FILE_PATH, "w") as file:
+            file.writelines(lines)
+
+def patch_manifest(simple_version: str):
+    """Patches the connector version within the connector init file"""
+    FILE_PATH = "bpy_speckle/blender_manifest.toml"
+    version = simple_version.split(".")
+
+    with open(FILE_PATH, "r") as file:
+        lines = file.readlines()
+
+        for (index, line) in enumerate(lines):
+            if line.startswith('version ='):
+                lines[index] = f'version = "{version[0]}.{version[1]}.{version[2]}",\n'
+                print(f"Patched connector version number in {FILE_PATH}")
                 break
 
-        with open(bpy_file, "w") as file:
+        with open(FILE_PATH, "w") as file:
             file.writelines(lines)
 
 def main():
@@ -24,7 +39,9 @@ def main():
         raise ValueError(f"Invalid tag provided: {tag}")
 
     print(f"Patching version: {tag}")
-    patch_connector(tag.split("-")[0])
+    simple_version = tag.split("-")[0]
+    patch_addon(simple_version)
+    patch_manifest(simple_version)
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -1,24 +1,14 @@
-[tool.poetry]
+[project]
 name = "speckle-blender"
-version = "2.0.0"
-description = "the Speckle 2.0 connector for Blender!"
-authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>", "Gergő Jedlicska <gergo@jedlicska.com>"]
+version = "3.0.0"
+description = "Next-Gen Speckle connector for Blender!"
+requires-python = ">=3.11.9, <4.0.0"
 license = "Apache-2.0"
+dependencies = ["specklepy>=3.0.0a11"]
 
-[tool.poetry.dependencies]
-python = ">=3.8, <4.0.0"
-specklepy = "^2.19.1"
-attrs = "^23.1.0"
+[dependency-groups]
+dev = [
+    "fake-bpy-module-latest>=20240524,<20240525",
+    "ruff>=0.4.4,<0.5",
+]
 
-# [tool.poetry.group.local_specklepy.dependencies]
-# specklepy = {path = "../specklepy", develop = true}
-
-[tool.poetry.group.dev.dependencies]
-fake-bpy-module-latest = "^20240524"
-black = "23.11.0"
-pylint = "^2.15.7"
-ruff = "^0.4.4"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

uv.lock

@@ -0,0 +1,700 @@
+version = 1
+revision = 1
+requires-python = ">=3.11.9, <4.0.0"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },
+]
+
+[[package]]
+name = "anyio"
+version = "4.5.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/f9/9a7ce600ebe7804daf90d4d48b1c0510a4561ddce43a596be46676f82343/anyio-4.5.2.tar.gz", hash = "sha256:23009af4ed04ce05991845451e11ef02fc7c5ed29179ac9a420e5ad0ac7ddc5b", size = 171293 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/b4/f7e396030e3b11394436358ca258a81d6010106582422f23443c16ca1873/anyio-4.5.2-py3-none-any.whl", hash = "sha256:c011ee36bc1e8ba40e5a81cb9df91925c218fe9b778554e0b56a21e1b5d4716f", size = 89766 },
+]
+
+[[package]]
+name = "appdirs"
+version = "1.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/d8/05696357e0311f5b5c316d7b95f46c669dd9c15aaeecbb48c7d0aeb88c40/appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41", size = 13470 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/00/2344469e2084fb287c2e0b57b72910309874c3245463acd6cf5e3db69324/appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128", size = 9566 },
+]
+
+[[package]]
+name = "attrs"
+version = "25.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/82/3c4e1d44f3cbaa2a578127d641fe385ba3bff6c38b789447ae11a21fa413/attrs-25.2.0.tar.gz", hash = "sha256:18a06db706db43ac232cce80443fcd9f2500702059ecf53489e3c5a3f417acaf", size = 812038 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/33/7a7388b9ef94aab40539939d94461ec682afbd895458945ed25be07f03f6/attrs-25.2.0-py3-none-any.whl", hash = "sha256:611344ff0a5fed735d86d7784610c84f8126b95e549bcad9ff61b4242f2d386b", size = 64016 },
+]
+
+[[package]]
+name = "backoff"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/47/d7/5bbeb12c44d7c4f2fb5b56abce497eb5ed9f34d85701de869acedd602619/backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba", size = 17001 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/73/b6e24bd22e6720ca8ee9a85a0c4a2971af8497d8f3193fa05390cbd46e09/backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8", size = 15148 },
+]
+
+[[package]]
+name = "certifi"
+version = "2024.8.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339 },
+    { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366 },
+    { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874 },
+    { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243 },
+    { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676 },
+    { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289 },
+    { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585 },
+    { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408 },
+    { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076 },
+    { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874 },
+    { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871 },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546 },
+    { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048 },
+    { url = "https://files.pythonhosted.org/packages/01/f8/38842422988b795220eb8038745d27a675ce066e2ada79516c118f291f07/charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99", size = 94389 },
+    { url = "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", size = 101752 },
+    { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 },
+    { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 },
+    { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 },
+    { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 },
+    { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 },
+    { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 },
+    { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 },
+    { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 },
+    { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 },
+    { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 },
+    { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 },
+    { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 },
+    { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 },
+    { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 },
+    { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 },
+    { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 },
+    { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 },
+    { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 },
+    { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 },
+    { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 },
+    { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 },
+    { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 },
+    { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 },
+    { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 },
+    { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 },
+    { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 },
+    { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 },
+    { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 },
+    { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 },
+]
+
+[[package]]
+name = "deprecated"
+version = "1.2.15"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/a3/53e7d78a6850ffdd394d7048a31a6f14e44900adedf190f9a165f6b69439/deprecated-1.2.15.tar.gz", hash = "sha256:683e561a90de76239796e6b6feac66b99030d2dd3fcf61ef996330f14bbb9b0d", size = 2977612 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/8f/c7f227eb42cfeaddce3eb0c96c60cbca37797fa7b34f8e1aeadf6c5c0983/Deprecated-1.2.15-py2.py3-none-any.whl", hash = "sha256:353bc4a8ac4bfc96800ddab349d89c25dec1079f65fd53acdcc1e0b975b21320", size = 9941 },
+]
+
+[[package]]
+name = "fake-bpy-module-latest"
+version = "20240524"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/d9/f92ba292561805c06eb688ea8eb3c44a8c519bc6a092d040084582809e98/fake_bpy_module_latest-20240524.tar.gz", hash = "sha256:752da840cf6e69b1e8898382a89b2107a98dc6cb45287d44ac32be1176f09bed", size = 967498 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/16/c2cb7912fd1ccc13a57ab43587ab4c97e3227ed15b7f890431031e31a1bd/fake_bpy_module_latest-20240524-py3-none-any.whl", hash = "sha256:909756548ac8d6fcdc647082442d0c544f872c55d9884ec85301d69e79837688", size = 1200494 },
+]
+
+[[package]]
+name = "gql"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "backoff" },
+    { name = "graphql-core" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/85/feda24b33adcc6c8463a62a8e2ca2cc3425dc6d687388ff728ceae231204/gql-3.5.0.tar.gz", hash = "sha256:ccb9c5db543682b28f577069950488218ed65d4ac70bb03b6929aaadaf636de9", size = 179939 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/fb/01a200e1c31b79690427c8e983014e4220d2652b4372a46fe4598e1d7a8e/gql-3.5.0-py2.py3-none-any.whl", hash = "sha256:70dda5694a5b194a8441f077aa5fb70cc94e4ec08016117523f013680901ecb7", size = 74001 },
+]
+
+[package.optional-dependencies]
+requests = [
+    { name = "requests" },
+    { name = "requests-toolbelt" },
+]
+websockets = [
+    { name = "websockets" },
+]
+
+[[package]]
+name = "graphql-core"
+version = "3.2.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/b5/ebc6fe3852e2d2fdaf682dddfc366934f3d2c9ef9b6d1b0e6ca348d936ba/graphql_core-3.2.5.tar.gz", hash = "sha256:e671b90ed653c808715645e3998b7ab67d382d55467b7e2978549111bbabf8d5", size = 504664 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/dc/078bd6b304de790618ebb95e2aedaadb78f4527ac43a9ad8815f006636b6/graphql_core-3.2.5-py3-none-any.whl", hash = "sha256:2f150d5096448aa4f8ab26268567bbfeef823769893b39c1a2e1409590939c8a", size = 203189 },
+]
+
+[[package]]
+name = "h11"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/41/d7d0a89eb493922c37d343b607bc1b5da7f5be7e383740b4753ad8943e90/httpcore-1.0.7.tar.gz", hash = "sha256:8551cb62a169ec7162ac7be8d4817d561f60e08eaa485234898414bb5a8a0b4c", size = 85196 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/f5/72347bc88306acb359581ac4d52f23c0ef445b57157adedb9aee0cd689d2/httpcore-1.0.7-py3-none-any.whl", hash = "sha256:a3fff8f43dc260d5bd363d9f9cf1830fa3a458b332856f34282de498ed420edd", size = 78551 },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+]
+
+[[package]]
+name = "multidict"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/be/504b89a5e9ca731cd47487e91c469064f8ae5af93b7259758dcfc2b9c848/multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a", size = 64002 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/13/df3505a46d0cd08428e4c8169a196131d1b0c4b515c3649829258843dde6/multidict-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3efe2c2cb5763f2f1b275ad2bf7a287d3f7ebbef35648a9726e3b69284a4f3d6", size = 48570 },
+    { url = "https://files.pythonhosted.org/packages/f0/e1/a215908bfae1343cdb72f805366592bdd60487b4232d039c437fe8f5013d/multidict-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7053d3b0353a8b9de430a4f4b4268ac9a4fb3481af37dfe49825bf45ca24156", size = 29316 },
+    { url = "https://files.pythonhosted.org/packages/70/0f/6dc70ddf5d442702ed74f298d69977f904960b82368532c88e854b79f72b/multidict-6.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27e5fc84ccef8dfaabb09d82b7d179c7cf1a3fbc8a966f8274fcb4ab2eb4cadb", size = 29640 },
+    { url = "https://files.pythonhosted.org/packages/d8/6d/9c87b73a13d1cdea30b321ef4b3824449866bd7f7127eceed066ccb9b9ff/multidict-6.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e2b90b43e696f25c62656389d32236e049568b39320e2735d51f08fd362761b", size = 131067 },
+    { url = "https://files.pythonhosted.org/packages/cc/1e/1b34154fef373371fd6c65125b3d42ff5f56c7ccc6bfff91b9b3c60ae9e0/multidict-6.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d83a047959d38a7ff552ff94be767b7fd79b831ad1cd9920662db05fec24fe72", size = 138507 },
+    { url = "https://files.pythonhosted.org/packages/fb/e0/0bc6b2bac6e461822b5f575eae85da6aae76d0e2a79b6665d6206b8e2e48/multidict-6.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1a9dd711d0877a1ece3d2e4fea11a8e75741ca21954c919406b44e7cf971304", size = 133905 },
+    { url = "https://files.pythonhosted.org/packages/ba/af/73d13b918071ff9b2205fcf773d316e0f8fefb4ec65354bbcf0b10908cc6/multidict-6.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2abea24d98246b94913b76a125e855eb5c434f7c46546046372fe60f666351", size = 129004 },
+    { url = "https://files.pythonhosted.org/packages/74/21/23960627b00ed39643302d81bcda44c9444ebcdc04ee5bedd0757513f259/multidict-6.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4867cafcbc6585e4b678876c489b9273b13e9fff9f6d6d66add5e15d11d926cb", size = 121308 },
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cf282263ffce4a596ed0bb2aa1a1dddfe1996d6a62d08842a8d4b33dca13/multidict-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b48204e8d955c47c55b72779802b219a39acc3ee3d0116d5080c388970b76e3", size = 132608 },
+    { url = "https://files.pythonhosted.org/packages/d7/3e/97e778c041c72063f42b290888daff008d3ab1427f5b09b714f5a8eff294/multidict-6.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d8fff389528cad1618fb4b26b95550327495462cd745d879a8c7c2115248e399", size = 127029 },
+    { url = "https://files.pythonhosted.org/packages/47/ac/3efb7bfe2f3aefcf8d103e9a7162572f01936155ab2f7ebcc7c255a23212/multidict-6.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a7a9541cd308eed5e30318430a9c74d2132e9a8cb46b901326272d780bf2d423", size = 137594 },
+    { url = "https://files.pythonhosted.org/packages/42/9b/6c6e9e8dc4f915fc90a9b7798c44a30773dea2995fdcb619870e705afe2b/multidict-6.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:da1758c76f50c39a2efd5e9859ce7d776317eb1dd34317c8152ac9251fc574a3", size = 134556 },
+    { url = "https://files.pythonhosted.org/packages/1d/10/8e881743b26aaf718379a14ac58572a240e8293a1c9d68e1418fb11c0f90/multidict-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c943a53e9186688b45b323602298ab727d8865d8c9ee0b17f8d62d14b56f0753", size = 130993 },
+    { url = "https://files.pythonhosted.org/packages/45/84/3eb91b4b557442802d058a7579e864b329968c8d0ea57d907e7023c677f2/multidict-6.1.0-cp311-cp311-win32.whl", hash = "sha256:90f8717cb649eea3504091e640a1b8568faad18bd4b9fcd692853a04475a4b80", size = 26405 },
+    { url = "https://files.pythonhosted.org/packages/9f/0b/ad879847ecbf6d27e90a6eabb7eff6b62c129eefe617ea45eae7c1f0aead/multidict-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:82176036e65644a6cc5bd619f65f6f19781e8ec2e5330f51aa9ada7504cc1926", size = 28795 },
+    { url = "https://files.pythonhosted.org/packages/fd/16/92057c74ba3b96d5e211b553895cd6dc7cc4d1e43d9ab8fafc727681ef71/multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa", size = 48713 },
+    { url = "https://files.pythonhosted.org/packages/94/3d/37d1b8893ae79716179540b89fc6a0ee56b4a65fcc0d63535c6f5d96f217/multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436", size = 29516 },
+    { url = "https://files.pythonhosted.org/packages/a2/12/adb6b3200c363062f805275b4c1e656be2b3681aada66c80129932ff0bae/multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761", size = 29557 },
+    { url = "https://files.pythonhosted.org/packages/47/e9/604bb05e6e5bce1e6a5cf80a474e0f072e80d8ac105f1b994a53e0b28c42/multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e", size = 130170 },
+    { url = "https://files.pythonhosted.org/packages/7e/13/9efa50801785eccbf7086b3c83b71a4fb501a4d43549c2f2f80b8787d69f/multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef", size = 134836 },
+    { url = "https://files.pythonhosted.org/packages/bf/0f/93808b765192780d117814a6dfcc2e75de6dcc610009ad408b8814dca3ba/multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95", size = 133475 },
+    { url = "https://files.pythonhosted.org/packages/d3/c8/529101d7176fe7dfe1d99604e48d69c5dfdcadb4f06561f465c8ef12b4df/multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925", size = 131049 },
+    { url = "https://files.pythonhosted.org/packages/ca/0c/fc85b439014d5a58063e19c3a158a889deec399d47b5269a0f3b6a2e28bc/multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966", size = 120370 },
+    { url = "https://files.pythonhosted.org/packages/db/46/d4416eb20176492d2258fbd47b4abe729ff3b6e9c829ea4236f93c865089/multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305", size = 125178 },
+    { url = "https://files.pythonhosted.org/packages/5b/46/73697ad7ec521df7de5531a32780bbfd908ded0643cbe457f981a701457c/multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2", size = 119567 },
+    { url = "https://files.pythonhosted.org/packages/cd/ed/51f060e2cb0e7635329fa6ff930aa5cffa17f4c7f5c6c3ddc3500708e2f2/multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2", size = 129822 },
+    { url = "https://files.pythonhosted.org/packages/df/9e/ee7d1954b1331da3eddea0c4e08d9142da5f14b1321c7301f5014f49d492/multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6", size = 128656 },
+    { url = "https://files.pythonhosted.org/packages/77/00/8538f11e3356b5d95fa4b024aa566cde7a38aa7a5f08f4912b32a037c5dc/multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3", size = 125360 },
+    { url = "https://files.pythonhosted.org/packages/be/05/5d334c1f2462d43fec2363cd00b1c44c93a78c3925d952e9a71caf662e96/multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133", size = 26382 },
+    { url = "https://files.pythonhosted.org/packages/a3/bf/f332a13486b1ed0496d624bcc7e8357bb8053823e8cd4b9a18edc1d97e73/multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1", size = 28529 },
+    { url = "https://files.pythonhosted.org/packages/22/67/1c7c0f39fe069aa4e5d794f323be24bf4d33d62d2a348acdb7991f8f30db/multidict-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d569388c381b24671589335a3be6e1d45546c2988c2ebe30fdcada8457a31008", size = 48771 },
+    { url = "https://files.pythonhosted.org/packages/3c/25/c186ee7b212bdf0df2519eacfb1981a017bda34392c67542c274651daf23/multidict-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:052e10d2d37810b99cc170b785945421141bf7bb7d2f8799d431e7db229c385f", size = 29533 },
+    { url = "https://files.pythonhosted.org/packages/67/5e/04575fd837e0958e324ca035b339cea174554f6f641d3fb2b4f2e7ff44a2/multidict-6.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f90c822a402cb865e396a504f9fc8173ef34212a342d92e362ca498cad308e28", size = 29595 },
+    { url = "https://files.pythonhosted.org/packages/d3/b2/e56388f86663810c07cfe4a3c3d87227f3811eeb2d08450b9e5d19d78876/multidict-6.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b225d95519a5bf73860323e633a664b0d85ad3d5bede6d30d95b35d4dfe8805b", size = 130094 },
+    { url = "https://files.pythonhosted.org/packages/6c/ee/30ae9b4186a644d284543d55d491fbd4239b015d36b23fea43b4c94f7052/multidict-6.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23bfd518810af7de1116313ebd9092cb9aa629beb12f6ed631ad53356ed6b86c", size = 134876 },
+    { url = "https://files.pythonhosted.org/packages/84/c7/70461c13ba8ce3c779503c70ec9d0345ae84de04521c1f45a04d5f48943d/multidict-6.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c09fcfdccdd0b57867577b719c69e347a436b86cd83747f179dbf0cc0d4c1f3", size = 133500 },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/002af221253f10f99959561123fae676148dd730e2daa2cd053846a58507/multidict-6.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf6bea52ec97e95560af5ae576bdac3aa3aae0b6758c6efa115236d9e07dae44", size = 131099 },
+    { url = "https://files.pythonhosted.org/packages/82/42/d1c7a7301d52af79d88548a97e297f9d99c961ad76bbe6f67442bb77f097/multidict-6.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57feec87371dbb3520da6192213c7d6fc892d5589a93db548331954de8248fd2", size = 120403 },
+    { url = "https://files.pythonhosted.org/packages/68/f3/471985c2c7ac707547553e8f37cff5158030d36bdec4414cb825fbaa5327/multidict-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0c3f390dc53279cbc8ba976e5f8035eab997829066756d811616b652b00a23a3", size = 125348 },
+    { url = "https://files.pythonhosted.org/packages/67/2c/e6df05c77e0e433c214ec1d21ddd203d9a4770a1f2866a8ca40a545869a0/multidict-6.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:59bfeae4b25ec05b34f1956eaa1cb38032282cd4dfabc5056d0a1ec4d696d3aa", size = 119673 },
+    { url = "https://files.pythonhosted.org/packages/c5/cd/bc8608fff06239c9fb333f9db7743a1b2eafe98c2666c9a196e867a3a0a4/multidict-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b2f59caeaf7632cc633b5cf6fc449372b83bbdf0da4ae04d5be36118e46cc0aa", size = 129927 },
+    { url = "https://files.pythonhosted.org/packages/44/8e/281b69b7bc84fc963a44dc6e0bbcc7150e517b91df368a27834299a526ac/multidict-6.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:37bb93b2178e02b7b618893990941900fd25b6b9ac0fa49931a40aecdf083fe4", size = 128711 },
+    { url = "https://files.pythonhosted.org/packages/12/a4/63e7cd38ed29dd9f1881d5119f272c898ca92536cdb53ffe0843197f6c85/multidict-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4e9f48f58c2c523d5a06faea47866cd35b32655c46b443f163d08c6d0ddb17d6", size = 125519 },
+    { url = "https://files.pythonhosted.org/packages/38/e0/4f5855037a72cd8a7a2f60a3952d9aa45feedb37ae7831642102604e8a37/multidict-6.1.0-cp313-cp313-win32.whl", hash = "sha256:3a37ffb35399029b45c6cc33640a92bef403c9fd388acce75cdc88f58bd19a81", size = 26426 },
+    { url = "https://files.pythonhosted.org/packages/7e/a5/17ee3a4db1e310b7405f5d25834460073a8ccd86198ce044dfaf69eac073/multidict-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9aa71e15d9d9beaad2c6b9319edcdc0a49a43ef5c0a4c8265ca9ee7d6c67774", size = 28531 },
+    { url = "https://files.pythonhosted.org/packages/99/b7/b9e70fde2c0f0c9af4cc5277782a89b66d35948ea3369ec9f598358c3ac5/multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506", size = 10051 },
+]
+
+[[package]]
+name = "propcache"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/4d/5e5a60b78dbc1d464f8a7bbaeb30957257afdc8512cbb9dfd5659304f5cd/propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70", size = 40951 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/1c/71eec730e12aec6511e702ad0cd73c2872eccb7cad39de8ba3ba9de693ef/propcache-0.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:63f13bf09cc3336eb04a837490b8f332e0db41da66995c9fd1ba04552e516354", size = 80811 },
+    { url = "https://files.pythonhosted.org/packages/89/c3/7e94009f9a4934c48a371632197406a8860b9f08e3f7f7d922ab69e57a41/propcache-0.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:608cce1da6f2672a56b24a015b42db4ac612ee709f3d29f27a00c943d9e851de", size = 46365 },
+    { url = "https://files.pythonhosted.org/packages/c0/1d/c700d16d1d6903aeab28372fe9999762f074b80b96a0ccc953175b858743/propcache-0.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:466c219deee4536fbc83c08d09115249db301550625c7fef1c5563a584c9bc87", size = 45602 },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/4a3e96380805bf742712e39a4534689f4cddf5fa2d3a93f22e9fd8001b23/propcache-0.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc2db02409338bf36590aa985a461b2c96fce91f8e7e0f14c50c5fcc4f229016", size = 236161 },
+    { url = "https://files.pythonhosted.org/packages/a5/85/90132481183d1436dff6e29f4fa81b891afb6cb89a7306f32ac500a25932/propcache-0.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a6ed8db0a556343d566a5c124ee483ae113acc9a557a807d439bcecc44e7dfbb", size = 244938 },
+    { url = "https://files.pythonhosted.org/packages/4a/89/c893533cb45c79c970834274e2d0f6d64383ec740be631b6a0a1d2b4ddc0/propcache-0.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:91997d9cb4a325b60d4e3f20967f8eb08dfcb32b22554d5ef78e6fd1dda743a2", size = 243576 },
+    { url = "https://files.pythonhosted.org/packages/8c/56/98c2054c8526331a05f205bf45cbb2cda4e58e56df70e76d6a509e5d6ec6/propcache-0.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c7dde9e533c0a49d802b4f3f218fa9ad0a1ce21f2c2eb80d5216565202acab4", size = 236011 },
+    { url = "https://files.pythonhosted.org/packages/2d/0c/8b8b9f8a6e1abd869c0fa79b907228e7abb966919047d294ef5df0d136cf/propcache-0.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffcad6c564fe6b9b8916c1aefbb37a362deebf9394bd2974e9d84232e3e08504", size = 224834 },
+    { url = "https://files.pythonhosted.org/packages/18/bb/397d05a7298b7711b90e13108db697732325cafdcd8484c894885c1bf109/propcache-0.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:97a58a28bcf63284e8b4d7b460cbee1edaab24634e82059c7b8c09e65284f178", size = 224946 },
+    { url = "https://files.pythonhosted.org/packages/25/19/4fc08dac19297ac58135c03770b42377be211622fd0147f015f78d47cd31/propcache-0.2.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:945db8ee295d3af9dbdbb698cce9bbc5c59b5c3fe328bbc4387f59a8a35f998d", size = 217280 },
+    { url = "https://files.pythonhosted.org/packages/7e/76/c79276a43df2096ce2aba07ce47576832b1174c0c480fe6b04bd70120e59/propcache-0.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:39e104da444a34830751715f45ef9fc537475ba21b7f1f5b0f4d71a3b60d7fe2", size = 220088 },
+    { url = "https://files.pythonhosted.org/packages/c3/9a/8a8cf428a91b1336b883f09c8b884e1734c87f724d74b917129a24fe2093/propcache-0.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c5ecca8f9bab618340c8e848d340baf68bcd8ad90a8ecd7a4524a81c1764b3db", size = 233008 },
+    { url = "https://files.pythonhosted.org/packages/25/7b/768a8969abd447d5f0f3333df85c6a5d94982a1bc9a89c53c154bf7a8b11/propcache-0.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c436130cc779806bdf5d5fae0d848713105472b8566b75ff70048c47d3961c5b", size = 237719 },
+    { url = "https://files.pythonhosted.org/packages/ed/0d/e5d68ccc7976ef8b57d80613ac07bbaf0614d43f4750cf953f0168ef114f/propcache-0.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:191db28dc6dcd29d1a3e063c3be0b40688ed76434622c53a284e5427565bbd9b", size = 227729 },
+    { url = "https://files.pythonhosted.org/packages/05/64/17eb2796e2d1c3d0c431dc5f40078d7282f4645af0bb4da9097fbb628c6c/propcache-0.2.0-cp311-cp311-win32.whl", hash = "sha256:5f2564ec89058ee7c7989a7b719115bdfe2a2fb8e7a4543b8d1c0cc4cf6478c1", size = 40473 },
+    { url = "https://files.pythonhosted.org/packages/83/c5/e89fc428ccdc897ade08cd7605f174c69390147526627a7650fb883e0cd0/propcache-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e2e54267980349b723cff366d1e29b138b9a60fa376664a157a342689553f71", size = 44921 },
+    { url = "https://files.pythonhosted.org/packages/7c/46/a41ca1097769fc548fc9216ec4c1471b772cc39720eb47ed7e38ef0006a9/propcache-0.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ee7606193fb267be4b2e3b32714f2d58cad27217638db98a60f9efb5efeccc2", size = 80800 },
+    { url = "https://files.pythonhosted.org/packages/75/4f/93df46aab9cc473498ff56be39b5f6ee1e33529223d7a4d8c0a6101a9ba2/propcache-0.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:91ee8fc02ca52e24bcb77b234f22afc03288e1dafbb1f88fe24db308910c4ac7", size = 46443 },
+    { url = "https://files.pythonhosted.org/packages/0b/17/308acc6aee65d0f9a8375e36c4807ac6605d1f38074b1581bd4042b9fb37/propcache-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2e900bad2a8456d00a113cad8c13343f3b1f327534e3589acc2219729237a2e8", size = 45676 },
+    { url = "https://files.pythonhosted.org/packages/65/44/626599d2854d6c1d4530b9a05e7ff2ee22b790358334b475ed7c89f7d625/propcache-0.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f52a68c21363c45297aca15561812d542f8fc683c85201df0bebe209e349f793", size = 246191 },
+    { url = "https://files.pythonhosted.org/packages/f2/df/5d996d7cb18df076debae7d76ac3da085c0575a9f2be6b1f707fe227b54c/propcache-0.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e41d67757ff4fbc8ef2af99b338bfb955010444b92929e9e55a6d4dcc3c4f09", size = 251791 },
+    { url = "https://files.pythonhosted.org/packages/2e/6d/9f91e5dde8b1f662f6dd4dff36098ed22a1ef4e08e1316f05f4758f1576c/propcache-0.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a64e32f8bd94c105cc27f42d3b658902b5bcc947ece3c8fe7bc1b05982f60e89", size = 253434 },
+    { url = "https://files.pythonhosted.org/packages/3c/e9/1b54b7e26f50b3e0497cd13d3483d781d284452c2c50dd2a615a92a087a3/propcache-0.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55346705687dbd7ef0d77883ab4f6fabc48232f587925bdaf95219bae072491e", size = 248150 },
+    { url = "https://files.pythonhosted.org/packages/a7/ef/a35bf191c8038fe3ce9a414b907371c81d102384eda5dbafe6f4dce0cf9b/propcache-0.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00181262b17e517df2cd85656fcd6b4e70946fe62cd625b9d74ac9977b64d8d9", size = 233568 },
+    { url = "https://files.pythonhosted.org/packages/97/d9/d00bb9277a9165a5e6d60f2142cd1a38a750045c9c12e47ae087f686d781/propcache-0.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6994984550eaf25dd7fc7bd1b700ff45c894149341725bb4edc67f0ffa94efa4", size = 229874 },
+    { url = "https://files.pythonhosted.org/packages/8e/78/c123cf22469bdc4b18efb78893e69c70a8b16de88e6160b69ca6bdd88b5d/propcache-0.2.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:56295eb1e5f3aecd516d91b00cfd8bf3a13991de5a479df9e27dd569ea23959c", size = 225857 },
+    { url = "https://files.pythonhosted.org/packages/31/1b/fd6b2f1f36d028820d35475be78859d8c89c8f091ad30e377ac49fd66359/propcache-0.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:439e76255daa0f8151d3cb325f6dd4a3e93043e6403e6491813bcaaaa8733887", size = 227604 },
+    { url = "https://files.pythonhosted.org/packages/99/36/b07be976edf77a07233ba712e53262937625af02154353171716894a86a6/propcache-0.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f6475a1b2ecb310c98c28d271a30df74f9dd436ee46d09236a6b750a7599ce57", size = 238430 },
+    { url = "https://files.pythonhosted.org/packages/0d/64/5822f496c9010e3966e934a011ac08cac8734561842bc7c1f65586e0683c/propcache-0.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3444cdba6628accf384e349014084b1cacd866fbb88433cd9d279d90a54e0b23", size = 244814 },
+    { url = "https://files.pythonhosted.org/packages/fd/bd/8657918a35d50b18a9e4d78a5df7b6c82a637a311ab20851eef4326305c1/propcache-0.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4a9d9b4d0a9b38d1c391bb4ad24aa65f306c6f01b512e10a8a34a2dc5675d348", size = 235922 },
+    { url = "https://files.pythonhosted.org/packages/a8/6f/ec0095e1647b4727db945213a9f395b1103c442ef65e54c62e92a72a3f75/propcache-0.2.0-cp312-cp312-win32.whl", hash = "sha256:69d3a98eebae99a420d4b28756c8ce6ea5a29291baf2dc9ff9414b42676f61d5", size = 40177 },
+    { url = "https://files.pythonhosted.org/packages/20/a2/bd0896fdc4f4c1db46d9bc361c8c79a9bf08ccc08ba054a98e38e7ba1557/propcache-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:ad9c9b99b05f163109466638bd30ada1722abb01bbb85c739c50b6dc11f92dc3", size = 44446 },
+    { url = "https://files.pythonhosted.org/packages/a8/a7/5f37b69197d4f558bfef5b4bceaff7c43cc9b51adf5bd75e9081d7ea80e4/propcache-0.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ecddc221a077a8132cf7c747d5352a15ed763b674c0448d811f408bf803d9ad7", size = 78120 },
+    { url = "https://files.pythonhosted.org/packages/c8/cd/48ab2b30a6b353ecb95a244915f85756d74f815862eb2ecc7a518d565b48/propcache-0.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0e53cb83fdd61cbd67202735e6a6687a7b491c8742dfc39c9e01e80354956763", size = 45127 },
+    { url = "https://files.pythonhosted.org/packages/a5/ba/0a1ef94a3412aab057bd996ed5f0ac7458be5bf469e85c70fa9ceb43290b/propcache-0.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92fe151145a990c22cbccf9ae15cae8ae9eddabfc949a219c9f667877e40853d", size = 44419 },
+    { url = "https://files.pythonhosted.org/packages/b4/6c/ca70bee4f22fa99eacd04f4d2f1699be9d13538ccf22b3169a61c60a27fa/propcache-0.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6a21ef516d36909931a2967621eecb256018aeb11fc48656e3257e73e2e247a", size = 229611 },
+    { url = "https://files.pythonhosted.org/packages/19/70/47b872a263e8511ca33718d96a10c17d3c853aefadeb86dc26e8421184b9/propcache-0.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f88a4095e913f98988f5b338c1d4d5d07dbb0b6bad19892fd447484e483ba6b", size = 234005 },
+    { url = "https://files.pythonhosted.org/packages/4f/be/3b0ab8c84a22e4a3224719099c1229ddfdd8a6a1558cf75cb55ee1e35c25/propcache-0.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a5b3bb545ead161be780ee85a2b54fdf7092815995661947812dde94a40f6fb", size = 237270 },
+    { url = "https://files.pythonhosted.org/packages/04/d8/f071bb000d4b8f851d312c3c75701e586b3f643fe14a2e3409b1b9ab3936/propcache-0.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67aeb72e0f482709991aa91345a831d0b707d16b0257e8ef88a2ad246a7280bf", size = 231877 },
+    { url = "https://files.pythonhosted.org/packages/93/e7/57a035a1359e542bbb0a7df95aad6b9871ebee6dce2840cb157a415bd1f3/propcache-0.2.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c997f8c44ec9b9b0bcbf2d422cc00a1d9b9c681f56efa6ca149a941e5560da2", size = 217848 },
+    { url = "https://files.pythonhosted.org/packages/f0/93/d1dea40f112ec183398fb6c42fde340edd7bab202411c4aa1a8289f461b6/propcache-0.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2a66df3d4992bc1d725b9aa803e8c5a66c010c65c741ad901e260ece77f58d2f", size = 216987 },
+    { url = "https://files.pythonhosted.org/packages/62/4c/877340871251145d3522c2b5d25c16a1690ad655fbab7bb9ece6b117e39f/propcache-0.2.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3ebbcf2a07621f29638799828b8d8668c421bfb94c6cb04269130d8de4fb7136", size = 212451 },
+    { url = "https://files.pythonhosted.org/packages/7c/bb/a91b72efeeb42906ef58ccf0cdb87947b54d7475fee3c93425d732f16a61/propcache-0.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1235c01ddaa80da8235741e80815ce381c5267f96cc49b1477fdcf8c047ef325", size = 212879 },
+    { url = "https://files.pythonhosted.org/packages/9b/7f/ee7fea8faac57b3ec5d91ff47470c6c5d40d7f15d0b1fccac806348fa59e/propcache-0.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3947483a381259c06921612550867b37d22e1df6d6d7e8361264b6d037595f44", size = 222288 },
+    { url = "https://files.pythonhosted.org/packages/ff/d7/acd67901c43d2e6b20a7a973d9d5fd543c6e277af29b1eb0e1f7bd7ca7d2/propcache-0.2.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d5bed7f9805cc29c780f3aee05de3262ee7ce1f47083cfe9f77471e9d6777e83", size = 228257 },
+    { url = "https://files.pythonhosted.org/packages/8d/6f/6272ecc7a8daad1d0754cfc6c8846076a8cb13f810005c79b15ce0ef0cf2/propcache-0.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4a91d44379f45f5e540971d41e4626dacd7f01004826a18cb048e7da7e96544", size = 221075 },
+    { url = "https://files.pythonhosted.org/packages/7c/bd/c7a6a719a6b3dd8b3aeadb3675b5783983529e4a3185946aa444d3e078f6/propcache-0.2.0-cp313-cp313-win32.whl", hash = "sha256:f902804113e032e2cdf8c71015651c97af6418363bea8d78dc0911d56c335032", size = 39654 },
+    { url = "https://files.pythonhosted.org/packages/88/e7/0eef39eff84fa3e001b44de0bd41c7c0e3432e7648ffd3d64955910f002d/propcache-0.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:8f188cfcc64fb1266f4684206c9de0e80f54622c3f22a910cbd200478aeae61e", size = 43705 },
+    { url = "https://files.pythonhosted.org/packages/3d/b6/e6d98278f2d49b22b4d033c9f792eda783b9ab2094b041f013fc69bcde87/propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036", size = 11603 },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.10.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/ae/d5220c5c52b158b1de7ca89fc5edb72f304a70a4c540c84c8844bf4008de/pydantic-2.10.6.tar.gz", hash = "sha256:ca5daa827cce33de7a42be142548b0096bf05a7e7b365aebfa5f8eeec7128236", size = 761681 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/3c/8cc1cc84deffa6e25d2d0c688ebb80635dfdbf1dbea3e30c541c8cf4d860/pydantic-2.10.6-py3-none-any.whl", hash = "sha256:427d664bf0b8a2b34ff5dd0f5a18df00591adcee7198fbd71981054cef37b584", size = 431696 },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.27.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/01/f3e5ac5e7c25833db5eb555f7b7ab24cd6f8c322d3a3ad2d67a952dc0abc/pydantic_core-2.27.2.tar.gz", hash = "sha256:eb026e5a4c1fee05726072337ff51d1efb6f59090b7da90d30ea58625b1ffb39", size = 413443 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/89/f3450af9d09d44eea1f2c369f49e8f181d742f28220f88cc4dfaae91ea6e/pydantic_core-2.27.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:8e10c99ef58cfdf2a66fc15d66b16c4a04f62bca39db589ae8cba08bc55331bc", size = 1893421 },
+    { url = "https://files.pythonhosted.org/packages/9e/e3/71fe85af2021f3f386da42d291412e5baf6ce7716bd7101ea49c810eda90/pydantic_core-2.27.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:26f32e0adf166a84d0cb63be85c562ca8a6fa8de28e5f0d92250c6b7e9e2aff7", size = 1814998 },
+    { url = "https://files.pythonhosted.org/packages/a6/3c/724039e0d848fd69dbf5806894e26479577316c6f0f112bacaf67aa889ac/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c19d1ea0673cd13cc2f872f6c9ab42acc4e4f492a7ca9d3795ce2b112dd7e15", size = 1826167 },
+    { url = "https://files.pythonhosted.org/packages/2b/5b/1b29e8c1fb5f3199a9a57c1452004ff39f494bbe9bdbe9a81e18172e40d3/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e68c4446fe0810e959cdff46ab0a41ce2f2c86d227d96dc3847af0ba7def306", size = 1865071 },
+    { url = "https://files.pythonhosted.org/packages/89/6c/3985203863d76bb7d7266e36970d7e3b6385148c18a68cc8915fd8c84d57/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9640b0059ff4f14d1f37321b94061c6db164fbe49b334b31643e0528d100d99", size = 2036244 },
+    { url = "https://files.pythonhosted.org/packages/0e/41/f15316858a246b5d723f7d7f599f79e37493b2e84bfc789e58d88c209f8a/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40d02e7d45c9f8af700f3452f329ead92da4c5f4317ca9b896de7ce7199ea459", size = 2737470 },
+    { url = "https://files.pythonhosted.org/packages/a8/7c/b860618c25678bbd6d1d99dbdfdf0510ccb50790099b963ff78a124b754f/pydantic_core-2.27.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c1fd185014191700554795c99b347d64f2bb637966c4cfc16998a0ca700d048", size = 1992291 },
+    { url = "https://files.pythonhosted.org/packages/bf/73/42c3742a391eccbeab39f15213ecda3104ae8682ba3c0c28069fbcb8c10d/pydantic_core-2.27.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d81d2068e1c1228a565af076598f9e7451712700b673de8f502f0334f281387d", size = 1994613 },
+    { url = "https://files.pythonhosted.org/packages/94/7a/941e89096d1175d56f59340f3a8ebaf20762fef222c298ea96d36a6328c5/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1a4207639fb02ec2dbb76227d7c751a20b1a6b4bc52850568e52260cae64ca3b", size = 2002355 },
+    { url = "https://files.pythonhosted.org/packages/6e/95/2359937a73d49e336a5a19848713555605d4d8d6940c3ec6c6c0ca4dcf25/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3de3ce3c9ddc8bbd88f6e0e304dea0e66d843ec9de1b0042b0911c1663ffd474", size = 2126661 },
+    { url = "https://files.pythonhosted.org/packages/2b/4c/ca02b7bdb6012a1adef21a50625b14f43ed4d11f1fc237f9d7490aa5078c/pydantic_core-2.27.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:30c5f68ded0c36466acede341551106821043e9afaad516adfb6e8fa80a4e6a6", size = 2153261 },
+    { url = "https://files.pythonhosted.org/packages/72/9d/a241db83f973049a1092a079272ffe2e3e82e98561ef6214ab53fe53b1c7/pydantic_core-2.27.2-cp311-cp311-win32.whl", hash = "sha256:c70c26d2c99f78b125a3459f8afe1aed4d9687c24fd677c6a4436bc042e50d6c", size = 1812361 },
+    { url = "https://files.pythonhosted.org/packages/e8/ef/013f07248041b74abd48a385e2110aa3a9bbfef0fbd97d4e6d07d2f5b89a/pydantic_core-2.27.2-cp311-cp311-win_amd64.whl", hash = "sha256:08e125dbdc505fa69ca7d9c499639ab6407cfa909214d500897d02afb816e7cc", size = 1982484 },
+    { url = "https://files.pythonhosted.org/packages/10/1c/16b3a3e3398fd29dca77cea0a1d998d6bde3902fa2706985191e2313cc76/pydantic_core-2.27.2-cp311-cp311-win_arm64.whl", hash = "sha256:26f0d68d4b235a2bae0c3fc585c585b4ecc51382db0e3ba402a22cbc440915e4", size = 1867102 },
+    { url = "https://files.pythonhosted.org/packages/d6/74/51c8a5482ca447871c93e142d9d4a92ead74de6c8dc5e66733e22c9bba89/pydantic_core-2.27.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9e0c8cfefa0ef83b4da9588448b6d8d2a2bf1a53c3f1ae5fca39eb3061e2f0b0", size = 1893127 },
+    { url = "https://files.pythonhosted.org/packages/d3/f3/c97e80721735868313c58b89d2de85fa80fe8dfeeed84dc51598b92a135e/pydantic_core-2.27.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:83097677b8e3bd7eaa6775720ec8e0405f1575015a463285a92bfdfe254529ef", size = 1811340 },
+    { url = "https://files.pythonhosted.org/packages/9e/91/840ec1375e686dbae1bd80a9e46c26a1e0083e1186abc610efa3d9a36180/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:172fce187655fece0c90d90a678424b013f8fbb0ca8b036ac266749c09438cb7", size = 1822900 },
+    { url = "https://files.pythonhosted.org/packages/f6/31/4240bc96025035500c18adc149aa6ffdf1a0062a4b525c932065ceb4d868/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:519f29f5213271eeeeb3093f662ba2fd512b91c5f188f3bb7b27bc5973816934", size = 1869177 },
+    { url = "https://files.pythonhosted.org/packages/fa/20/02fbaadb7808be578317015c462655c317a77a7c8f0ef274bc016a784c54/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:05e3a55d124407fffba0dd6b0c0cd056d10e983ceb4e5dbd10dda135c31071d6", size = 2038046 },
+    { url = "https://files.pythonhosted.org/packages/06/86/7f306b904e6c9eccf0668248b3f272090e49c275bc488a7b88b0823444a4/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9c3ed807c7b91de05e63930188f19e921d1fe90de6b4f5cd43ee7fcc3525cb8c", size = 2685386 },
+    { url = "https://files.pythonhosted.org/packages/8d/f0/49129b27c43396581a635d8710dae54a791b17dfc50c70164866bbf865e3/pydantic_core-2.27.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fb4aadc0b9a0c063206846d603b92030eb6f03069151a625667f982887153e2", size = 1997060 },
+    { url = "https://files.pythonhosted.org/packages/0d/0f/943b4af7cd416c477fd40b187036c4f89b416a33d3cc0ab7b82708a667aa/pydantic_core-2.27.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28ccb213807e037460326424ceb8b5245acb88f32f3d2777427476e1b32c48c4", size = 2004870 },
+    { url = "https://files.pythonhosted.org/packages/35/40/aea70b5b1a63911c53a4c8117c0a828d6790483f858041f47bab0b779f44/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:de3cd1899e2c279b140adde9357c4495ed9d47131b4a4eaff9052f23398076b3", size = 1999822 },
+    { url = "https://files.pythonhosted.org/packages/f2/b3/807b94fd337d58effc5498fd1a7a4d9d59af4133e83e32ae39a96fddec9d/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:220f892729375e2d736b97d0e51466252ad84c51857d4d15f5e9692f9ef12be4", size = 2130364 },
+    { url = "https://files.pythonhosted.org/packages/fc/df/791c827cd4ee6efd59248dca9369fb35e80a9484462c33c6649a8d02b565/pydantic_core-2.27.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a0fcd29cd6b4e74fe8ddd2c90330fd8edf2e30cb52acda47f06dd615ae72da57", size = 2158303 },
+    { url = "https://files.pythonhosted.org/packages/9b/67/4e197c300976af185b7cef4c02203e175fb127e414125916bf1128b639a9/pydantic_core-2.27.2-cp312-cp312-win32.whl", hash = "sha256:1e2cb691ed9834cd6a8be61228471d0a503731abfb42f82458ff27be7b2186fc", size = 1834064 },
+    { url = "https://files.pythonhosted.org/packages/1f/ea/cd7209a889163b8dcca139fe32b9687dd05249161a3edda62860430457a5/pydantic_core-2.27.2-cp312-cp312-win_amd64.whl", hash = "sha256:cc3f1a99a4f4f9dd1de4fe0312c114e740b5ddead65bb4102884b384c15d8bc9", size = 1989046 },
+    { url = "https://files.pythonhosted.org/packages/bc/49/c54baab2f4658c26ac633d798dab66b4c3a9bbf47cff5284e9c182f4137a/pydantic_core-2.27.2-cp312-cp312-win_arm64.whl", hash = "sha256:3911ac9284cd8a1792d3cb26a2da18f3ca26c6908cc434a18f730dc0db7bfa3b", size = 1885092 },
+    { url = "https://files.pythonhosted.org/packages/41/b1/9bc383f48f8002f99104e3acff6cba1231b29ef76cfa45d1506a5cad1f84/pydantic_core-2.27.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d14bd329640e63852364c306f4d23eb744e0f8193148d4044dd3dacdaacbd8b", size = 1892709 },
+    { url = "https://files.pythonhosted.org/packages/10/6c/e62b8657b834f3eb2961b49ec8e301eb99946245e70bf42c8817350cbefc/pydantic_core-2.27.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82f91663004eb8ed30ff478d77c4d1179b3563df6cdb15c0817cd1cdaf34d154", size = 1811273 },
+    { url = "https://files.pythonhosted.org/packages/ba/15/52cfe49c8c986e081b863b102d6b859d9defc63446b642ccbbb3742bf371/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71b24c7d61131bb83df10cc7e687433609963a944ccf45190cfc21e0887b08c9", size = 1823027 },
+    { url = "https://files.pythonhosted.org/packages/b1/1c/b6f402cfc18ec0024120602bdbcebc7bdd5b856528c013bd4d13865ca473/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fa8e459d4954f608fa26116118bb67f56b93b209c39b008277ace29937453dc9", size = 1868888 },
+    { url = "https://files.pythonhosted.org/packages/bd/7b/8cb75b66ac37bc2975a3b7de99f3c6f355fcc4d89820b61dffa8f1e81677/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8918cbebc8da707ba805b7fd0b382816858728ae7fe19a942080c24e5b7cd1", size = 2037738 },
+    { url = "https://files.pythonhosted.org/packages/c8/f1/786d8fe78970a06f61df22cba58e365ce304bf9b9f46cc71c8c424e0c334/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eda3f5c2a021bbc5d976107bb302e0131351c2ba54343f8a496dc8783d3d3a6a", size = 2685138 },
+    { url = "https://files.pythonhosted.org/packages/a6/74/d12b2cd841d8724dc8ffb13fc5cef86566a53ed358103150209ecd5d1999/pydantic_core-2.27.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8086fa684c4775c27f03f062cbb9eaa6e17f064307e86b21b9e0abc9c0f02e", size = 1997025 },
+    { url = "https://files.pythonhosted.org/packages/a0/6e/940bcd631bc4d9a06c9539b51f070b66e8f370ed0933f392db6ff350d873/pydantic_core-2.27.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8d9b3388db186ba0c099a6d20f0604a44eabdeef1777ddd94786cdae158729e4", size = 2004633 },
+    { url = "https://files.pythonhosted.org/packages/50/cc/a46b34f1708d82498c227d5d80ce615b2dd502ddcfd8376fc14a36655af1/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7a66efda2387de898c8f38c0cf7f14fca0b51a8ef0b24bfea5849f1b3c95af27", size = 1999404 },
+    { url = "https://files.pythonhosted.org/packages/ca/2d/c365cfa930ed23bc58c41463bae347d1005537dc8db79e998af8ba28d35e/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:18a101c168e4e092ab40dbc2503bdc0f62010e95d292b27827871dc85450d7ee", size = 2130130 },
+    { url = "https://files.pythonhosted.org/packages/f4/d7/eb64d015c350b7cdb371145b54d96c919d4db516817f31cd1c650cae3b21/pydantic_core-2.27.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ba5dd002f88b78a4215ed2f8ddbdf85e8513382820ba15ad5ad8955ce0ca19a1", size = 2157946 },
+    { url = "https://files.pythonhosted.org/packages/a4/99/bddde3ddde76c03b65dfd5a66ab436c4e58ffc42927d4ff1198ffbf96f5f/pydantic_core-2.27.2-cp313-cp313-win32.whl", hash = "sha256:1ebaf1d0481914d004a573394f4be3a7616334be70261007e47c2a6fe7e50130", size = 1834387 },
+    { url = "https://files.pythonhosted.org/packages/71/47/82b5e846e01b26ac6f1893d3c5f9f3a2eb6ba79be26eef0b759b4fe72946/pydantic_core-2.27.2-cp313-cp313-win_amd64.whl", hash = "sha256:953101387ecf2f5652883208769a79e48db18c6df442568a0b5ccd8c2723abee", size = 1990453 },
+    { url = "https://files.pythonhosted.org/packages/51/b2/b2b50d5ecf21acf870190ae5d093602d95f66c9c31f9d5de6062eb329ad1/pydantic_core-2.27.2-cp313-cp313-win_arm64.whl", hash = "sha256:ac4dbfd1691affb8f48c2c13241a2e3b60ff23247cbcf981759c768b6633cf8b", size = 1885186 },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.8.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/82/c79424d7d8c29b994fb01d277da57b0a9b09cc03c3ff875f9bd8a86b2145/pydantic_settings-2.8.1.tar.gz", hash = "sha256:d5c663dfbe9db9d5e1c646b2e161da12f0d734d422ee56f567d0ea2cee4e8585", size = 83550 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/53/a64f03044927dc47aafe029c42a5b7aabc38dfb813475e0e1bf71c4a59d0/pydantic_settings-2.8.1-py3-none-any.whl", hash = "sha256:81942d5ac3d905f7f3ee1a70df5dfb62d5569c12f51a5a647defc1c3d9ee2e9c", size = 30839 },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 },
+]
+
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481 },
+]
+
+[[package]]
+name = "ruff"
+version = "0.4.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/04/b660bc832ebfa40e1788edf6934388340751cbc6f733d1f807edca9d96e6/ruff-0.4.10.tar.gz", hash = "sha256:3aa4f2bc388a30d346c56524f7cacca85945ba124945fe489952aadb6b5cd804", size = 2577674 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/0d/134fdd72f566d37b0c59b6e55f60993c705f93a0fe3c1faa6f8a269057c7/ruff-0.4.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5c2c4d0859305ac5a16310eec40e4e9a9dec5dcdfbe92697acd99624e8638dac", size = 8510271 },
+    { url = "https://files.pythonhosted.org/packages/46/5e/4ac799ffec39ef5012052c1f144a0f7a63a0322ebd328b802d64beb3d091/ruff-0.4.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a79489607d1495685cdd911a323a35871abfb7a95d4f98fc6f85e799227ac46e", size = 8107776 },
+    { url = "https://files.pythonhosted.org/packages/78/6f/37af054d3ced5a6196201f6c248eeaec6b3b844136cf3da510d591dbfd89/ruff-0.4.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1dd1681dfa90a41b8376a61af05cc4dc5ff32c8f14f5fe20dba9ff5deb80cd6", size = 9868358 },
+    { url = "https://files.pythonhosted.org/packages/c7/38/070baf0393ba0da9d85409bdd63874776926acfc372e8e9f0ed21957aeee/ruff-0.4.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c75c53bb79d71310dc79fb69eb4902fba804a81f374bc86a9b117a8d077a1784", size = 9172824 },
+    { url = "https://files.pythonhosted.org/packages/e7/9d/bad51d81c918e1ce1648b24480a63f5605662efe69b55fad05825b5711ff/ruff-0.4.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18238c80ee3d9100d3535d8eb15a59c4a0753b45cc55f8bf38f38d6a597b9739", size = 9997887 },
+    { url = "https://files.pythonhosted.org/packages/ec/a4/1310b3d003cb67f3c86cb8cc5c5e475dab152b1eef88558abd11e55daaad/ruff-0.4.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:d8f71885bce242da344989cae08e263de29752f094233f932d4f5cfb4ef36a81", size = 10743762 },
+    { url = "https://files.pythonhosted.org/packages/b8/c1/5373bc5a4c3782c0a368ce5ca4ec3a689574daf71f68f55720a6a64321d4/ruff-0.4.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:330421543bd3222cdfec481e8ff3460e8702ed1e58b494cf9d9e4bf90db52b9d", size = 10329524 },
+    { url = "https://files.pythonhosted.org/packages/48/dc/2c057e7717a3eaaa89ea848a26ef085930a2509f9b66ceae55319668c03d/ruff-0.4.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e9b6fb3a37b772628415b00c4fc892f97954275394ed611056a4b8a2631365e", size = 11208593 },
+    { url = "https://files.pythonhosted.org/packages/11/c3/3f89b1e967a869642bd9198f27e2b89b8300862555d3e1e39b4ccaf92e8b/ruff-0.4.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f54c481b39a762d48f64d97351048e842861c6662d63ec599f67d515cb417f6", size = 10041835 },
+    { url = "https://files.pythonhosted.org/packages/d0/e6/734aed23112de8df5a2f3bc02e9e45cd3910fe83b0d2bb2456e200c52d98/ruff-0.4.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:67fe086b433b965c22de0b4259ddfe6fa541c95bf418499bedb9ad5fb8d1c631", size = 9842683 },
+    { url = "https://files.pythonhosted.org/packages/cf/13/bc788b2e21d3e4db74d1375da22f50f944bc1fef064c4749f307b0c8794f/ruff-0.4.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:acfaaab59543382085f9eb51f8e87bac26bf96b164839955f244d07125a982ef", size = 9283929 },
+    { url = "https://files.pythonhosted.org/packages/f0/09/f3c6560f9d81a4c5d800996090c9cc54d794ea14ab8f8af46b7483005963/ruff-0.4.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:3cea07079962b2941244191569cf3a05541477286f5cafea638cd3aa94b56815", size = 9617526 },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/11ae4e8587efe40aa083835665d0818626f8f4a10aa4ebc097cdbfae7624/ruff-0.4.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:338a64ef0748f8c3a80d7f05785930f7965d71ca260904a9321d13be24b79695", size = 10114053 },
+    { url = "https://files.pythonhosted.org/packages/e8/94/3bb62a0086e9c61d0506e546e7cf68456fd93bf569a8adfa5e324812970d/ruff-0.4.10-py3-none-win32.whl", hash = "sha256:ffe3cd2f89cb54561c62e5fa20e8f182c0a444934bf430515a4b422f1ab7b7ca", size = 7707741 },
+    { url = "https://files.pythonhosted.org/packages/d8/4e/6fd32ebd0a09f25ed9911b77c5273b7a6b3b50a78d6ed0508d66a24398b8/ruff-0.4.10-py3-none-win_amd64.whl", hash = "sha256:67f67cef43c55ffc8cc59e8e0b97e9e60b4837c8f21e8ab5ffd5d66e196e25f7", size = 8519153 },
+    { url = "https://files.pythonhosted.org/packages/dc/78/5109b7db3b44a64157b025e45eec6591e4beb53732104637d8e0ee0c5570/ruff-0.4.10-py3-none-win_arm64.whl", hash = "sha256:dd1fcee327c20addac7916ca4e2653fbbf2e8388d8a6477ce5b4e986b68ae6c0", size = 7906942 },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
+]
+
+[[package]]
+name = "speckle-blender"
+version = "3.0.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "specklepy" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "fake-bpy-module-latest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "specklepy", specifier = ">=3.0.0a4" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fake-bpy-module-latest", specifier = ">=20240524,<20240525" },
+    { name = "ruff", specifier = ">=0.4.4,<0.5" },
+]
+
+[[package]]
+name = "specklepy"
+version = "3.0.0a4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "appdirs" },
+    { name = "attrs" },
+    { name = "deprecated" },
+    { name = "gql", extra = ["requests", "websockets"] },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "ujson" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/40/0df270e2b0eb4a58ebfcef396261a20e2d9d89518269f770d136b1e0885b/specklepy-3.0.0a4.tar.gz", hash = "sha256:36164e90f4b018f89837d4200ca0260c13b833c6f2569cc53a4024bf0657a2d0", size = 201224 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/90/6db2f012fde0618142449801854549b4aab91cb3b821ba01d40f79160f11/specklepy-3.0.0a4-py3-none-any.whl", hash = "sha256:776ae24e1f010c8830dbb5c3c0c53707a43fb42a43cbf9fb8d5c6081f2d7b457", size = 113919 },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]
+
+[[package]]
+name = "ujson"
+version = "5.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/00/3110fd566786bfa542adb7932d62035e0c0ef662a8ff6544b6643b3d6fd7/ujson-5.10.0.tar.gz", hash = "sha256:b3cd8f3c5d8c7738257f1018880444f7b7d9b66232c64649f562d7ba86ad4bc1", size = 7154885 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/23/ec/3c551ecfe048bcb3948725251fb0214b5844a12aa60bee08d78315bb1c39/ujson-5.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a5b366812c90e69d0f379a53648be10a5db38f9d4ad212b60af00bd4048d0f00", size = 55353 },
+    { url = "https://files.pythonhosted.org/packages/8d/9f/4731ef0671a0653e9f5ba18db7c4596d8ecbf80c7922dd5fe4150f1aea76/ujson-5.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:502bf475781e8167f0f9d0e41cd32879d120a524b22358e7f205294224c71126", size = 51813 },
+    { url = "https://files.pythonhosted.org/packages/1f/2b/44d6b9c1688330bf011f9abfdb08911a9dc74f76926dde74e718d87600da/ujson-5.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b91b5d0d9d283e085e821651184a647699430705b15bf274c7896f23fe9c9d8", size = 51988 },
+    { url = "https://files.pythonhosted.org/packages/29/45/f5f5667427c1ec3383478092a414063ddd0dfbebbcc533538fe37068a0a3/ujson-5.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:129e39af3a6d85b9c26d5577169c21d53821d8cf68e079060602e861c6e5da1b", size = 53561 },
+    { url = "https://files.pythonhosted.org/packages/26/21/a0c265cda4dd225ec1be595f844661732c13560ad06378760036fc622587/ujson-5.10.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f77b74475c462cb8b88680471193064d3e715c7c6074b1c8c412cb526466efe9", size = 58497 },
+    { url = "https://files.pythonhosted.org/packages/28/36/8fde862094fd2342ccc427a6a8584fed294055fdee341661c78660f7aef3/ujson-5.10.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ec0ca8c415e81aa4123501fee7f761abf4b7f386aad348501a26940beb1860f", size = 997877 },
+    { url = "https://files.pythonhosted.org/packages/90/37/9208e40d53baa6da9b6a1c719e0670c3f474c8fc7cc2f1e939ec21c1bc93/ujson-5.10.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab13a2a9e0b2865a6c6db9271f4b46af1c7476bfd51af1f64585e919b7c07fd4", size = 1140632 },
+    { url = "https://files.pythonhosted.org/packages/89/d5/2626c87c59802863d44d19e35ad16b7e658e4ac190b0dead17ff25460b4c/ujson-5.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:57aaf98b92d72fc70886b5a0e1a1ca52c2320377360341715dd3933a18e827b1", size = 1043513 },
+    { url = "https://files.pythonhosted.org/packages/2f/ee/03662ce9b3f16855770f0d70f10f0978ba6210805aa310c4eebe66d36476/ujson-5.10.0-cp311-cp311-win32.whl", hash = "sha256:2987713a490ceb27edff77fb184ed09acdc565db700ee852823c3dc3cffe455f", size = 38616 },
+    { url = "https://files.pythonhosted.org/packages/3e/20/952dbed5895835ea0b82e81a7be4ebb83f93b079d4d1ead93fcddb3075af/ujson-5.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:f00ea7e00447918ee0eff2422c4add4c5752b1b60e88fcb3c067d4a21049a720", size = 42071 },
+    { url = "https://files.pythonhosted.org/packages/e8/a6/fd3f8bbd80842267e2d06c3583279555e8354c5986c952385199d57a5b6c/ujson-5.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:98ba15d8cbc481ce55695beee9f063189dce91a4b08bc1d03e7f0152cd4bbdd5", size = 55642 },
+    { url = "https://files.pythonhosted.org/packages/a8/47/dd03fd2b5ae727e16d5d18919b383959c6d269c7b948a380fdd879518640/ujson-5.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9d2edbf1556e4f56e50fab7d8ff993dbad7f54bac68eacdd27a8f55f433578e", size = 51807 },
+    { url = "https://files.pythonhosted.org/packages/25/23/079a4cc6fd7e2655a473ed9e776ddbb7144e27f04e8fc484a0fb45fe6f71/ujson-5.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6627029ae4f52d0e1a2451768c2c37c0c814ffc04f796eb36244cf16b8e57043", size = 51972 },
+    { url = "https://files.pythonhosted.org/packages/04/81/668707e5f2177791869b624be4c06fb2473bf97ee33296b18d1cf3092af7/ujson-5.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8ccb77b3e40b151e20519c6ae6d89bfe3f4c14e8e210d910287f778368bb3d1", size = 53686 },
+    { url = "https://files.pythonhosted.org/packages/bd/50/056d518a386d80aaf4505ccf3cee1c40d312a46901ed494d5711dd939bc3/ujson-5.10.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3caf9cd64abfeb11a3b661329085c5e167abbe15256b3b68cb5d914ba7396f3", size = 58591 },
+    { url = "https://files.pythonhosted.org/packages/fc/d6/aeaf3e2d6fb1f4cfb6bf25f454d60490ed8146ddc0600fae44bfe7eb5a72/ujson-5.10.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6e32abdce572e3a8c3d02c886c704a38a1b015a1fb858004e03d20ca7cecbb21", size = 997853 },
+    { url = "https://files.pythonhosted.org/packages/f8/d5/1f2a5d2699f447f7d990334ca96e90065ea7f99b142ce96e85f26d7e78e2/ujson-5.10.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a65b6af4d903103ee7b6f4f5b85f1bfd0c90ba4eeac6421aae436c9988aa64a2", size = 1140689 },
+    { url = "https://files.pythonhosted.org/packages/f2/2c/6990f4ccb41ed93744aaaa3786394bca0875503f97690622f3cafc0adfde/ujson-5.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:604a046d966457b6cdcacc5aa2ec5314f0e8c42bae52842c1e6fa02ea4bda42e", size = 1043576 },
+    { url = "https://files.pythonhosted.org/packages/14/f5/a2368463dbb09fbdbf6a696062d0c0f62e4ae6fa65f38f829611da2e8fdd/ujson-5.10.0-cp312-cp312-win32.whl", hash = "sha256:6dea1c8b4fc921bf78a8ff00bbd2bfe166345f5536c510671bccececb187c80e", size = 38764 },
+    { url = "https://files.pythonhosted.org/packages/59/2d/691f741ffd72b6c84438a93749ac57bf1a3f217ac4b0ea4fd0e96119e118/ujson-5.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:38665e7d8290188b1e0d57d584eb8110951a9591363316dd41cf8686ab1d0abc", size = 42211 },
+    { url = "https://files.pythonhosted.org/packages/0d/69/b3e3f924bb0e8820bb46671979770c5be6a7d51c77a66324cdb09f1acddb/ujson-5.10.0-cp313-cp313-macosx_10_9_x86_64.whl", hash = "sha256:618efd84dc1acbd6bff8eaa736bb6c074bfa8b8a98f55b61c38d4ca2c1f7f287", size = 55646 },
+    { url = "https://files.pythonhosted.org/packages/32/8a/9b748eb543c6cabc54ebeaa1f28035b1bd09c0800235b08e85990734c41e/ujson-5.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:38d5d36b4aedfe81dfe251f76c0467399d575d1395a1755de391e58985ab1c2e", size = 51806 },
+    { url = "https://files.pythonhosted.org/packages/39/50/4b53ea234413b710a18b305f465b328e306ba9592e13a791a6a6b378869b/ujson-5.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67079b1f9fb29ed9a2914acf4ef6c02844b3153913eb735d4bf287ee1db6e557", size = 51975 },
+    { url = "https://files.pythonhosted.org/packages/b4/9d/8061934f960cdb6dd55f0b3ceeff207fcc48c64f58b43403777ad5623d9e/ujson-5.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7d0e0ceeb8fe2468c70ec0c37b439dd554e2aa539a8a56365fd761edb418988", size = 53693 },
+    { url = "https://files.pythonhosted.org/packages/f5/be/7bfa84b28519ddbb67efc8410765ca7da55e6b93aba84d97764cd5794dbc/ujson-5.10.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:59e02cd37bc7c44d587a0ba45347cc815fb7a5fe48de16bf05caa5f7d0d2e816", size = 58594 },
+    { url = "https://files.pythonhosted.org/packages/48/eb/85d465abafb2c69d9699cfa5520e6e96561db787d36c677370e066c7e2e7/ujson-5.10.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2a890b706b64e0065f02577bf6d8ca3b66c11a5e81fb75d757233a38c07a1f20", size = 997853 },
+    { url = "https://files.pythonhosted.org/packages/9f/76/2a63409fc05d34dd7d929357b7a45e3a2c96f22b4225cd74becd2ba6c4cb/ujson-5.10.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:621e34b4632c740ecb491efc7f1fcb4f74b48ddb55e65221995e74e2d00bbff0", size = 1140694 },
+    { url = "https://files.pythonhosted.org/packages/45/ed/582c4daba0f3e1688d923b5cb914ada1f9defa702df38a1916c899f7c4d1/ujson-5.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9500e61fce0cfc86168b248104e954fead61f9be213087153d272e817ec7b4f", size = 1043580 },
+    { url = "https://files.pythonhosted.org/packages/d7/0c/9837fece153051e19c7bade9f88f9b409e026b9525927824cdf16293b43b/ujson-5.10.0-cp313-cp313-win32.whl", hash = "sha256:4c4fc16f11ac1612f05b6f5781b384716719547e142cfd67b65d035bd85af165", size = 38766 },
+    { url = "https://files.pythonhosted.org/packages/d7/72/6cb6728e2738c05bbe9bd522d6fc79f86b9a28402f38663e85a28fddd4a0/ujson-5.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:4573fd1695932d4f619928fd09d5d03d917274381649ade4328091ceca175539", size = 42212 },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 },
+]
+
+[[package]]
+name = "websockets"
+version = "11.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/3b/2ed38e52eed4cf277f9df5f0463a99199a04d9e29c9e227cfafa57bd3993/websockets-11.0.3.tar.gz", hash = "sha256:88fc51d9a26b10fc331be344f1781224a375b78488fc343620184e95a4b27016", size = 104235 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/49/ae616bd221efba84a3d78737b417f704af1ffa36f40dcaba5eb954dd4753/websockets-11.0.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e848f46a58b9fcf3d06061d17be388caf70ea5b8cc3466251963c8345e13f7eb", size = 123748 },
+    { url = "https://files.pythonhosted.org/packages/0a/84/68b848a373493b58615d6c10e9e8ccbaadfd540f84905421739a807704f8/websockets-11.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:aa5003845cdd21ac0dc6c9bf661c5beddd01116f6eb9eb3c8e272353d45b3288", size = 120975 },
+    { url = "https://files.pythonhosted.org/packages/8c/a8/e81533499f84ef6cdd95d11d5b05fa827c0f097925afd86f16e6a2631d8e/websockets-11.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b58cbf0697721120866820b89f93659abc31c1e876bf20d0b3d03cef14faf84d", size = 121017 },
+    { url = "https://files.pythonhosted.org/packages/6b/ca/65d6986665888494eca4d5435a9741c822022996f0f4200c57ce4b9242f7/websockets-11.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:660e2d9068d2bedc0912af508f30bbeb505bbbf9774d98def45f68278cea20d3", size = 131200 },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/a8a582ebeeecc8b5f332997d44c57e241748f8a9856e06a38a5a13b30796/websockets-11.0.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c1f0524f203e3bd35149f12157438f406eff2e4fb30f71221c8a5eceb3617b6b", size = 130195 },
+    { url = "https://files.pythonhosted.org/packages/a9/5e/b25c60067d700e811dccb4e3c318eeadd3a19d8b3620de9f97434af777a7/websockets-11.0.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:def07915168ac8f7853812cc593c71185a16216e9e4fa886358a17ed0fd9fcf6", size = 130569 },
+    { url = "https://files.pythonhosted.org/packages/14/fc/5cbbf439c925e1e184a0392ec477a30cee2fabc0e63807c1d4b6d570fb52/websockets-11.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b30c6590146e53149f04e85a6e4fcae068df4289e31e4aee1fdf56a0dead8f97", size = 136015 },
+    { url = "https://files.pythonhosted.org/packages/0f/d8/a997d3546aef9cc995a1126f7d7ade96c0e16c1a0efb9d2d430aee57c925/websockets-11.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:619d9f06372b3a42bc29d0cd0354c9bb9fb39c2cbc1a9c5025b4538738dbffaf", size = 135292 },
+    { url = "https://files.pythonhosted.org/packages/89/8f/707a05d5725f956c78d252a5fd73b89fa3ac57dd3959381c2d1acb41cb13/websockets-11.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:01f5567d9cf6f502d655151645d4e8b72b453413d3819d2b6f1185abc23e82dd", size = 135890 },
+    { url = "https://files.pythonhosted.org/packages/b5/94/ac47552208583d5dbcce468430c1eb2ae18962f6b3a694a2b7727cc60d4a/websockets-11.0.3-cp311-cp311-win32.whl", hash = "sha256:e1459677e5d12be8bbc7584c35b992eea142911a6236a3278b9b5ce3326f282c", size = 124149 },
+    { url = "https://files.pythonhosted.org/packages/e1/7c/0ad6e7ef0a054d73092f616d20d3d9bd3e1b837554cb20a52d8dd9f5b049/websockets-11.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:e7837cb169eca3b3ae94cc5787c4fed99eef74c0ab9506756eea335e0d6f3ed8", size = 124670 },
+    { url = "https://files.pythonhosted.org/packages/47/96/9d5749106ff57629b54360664ae7eb9afd8302fad1680ead385383e33746/websockets-11.0.3-py3-none-any.whl", hash = "sha256:6681ba9e7f8f3b19440921e99efbb40fc89f26cd71bf539e45d8c8a25c976dc6", size = 118056 },
+]
+
+[[package]]
+name = "wrapt"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/a1/fc03dca9b0432725c2e8cdbf91a349d2194cf03d8523c124faebe581de09/wrapt-1.17.0.tar.gz", hash = "sha256:16187aa2317c731170a88ef35e8937ae0f533c402872c1ee5e6d079fcf320801", size = 55542 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/40/def56538acddc2f764c157d565b9f989072a1d2f2a8e384324e2e104fc7d/wrapt-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:74bf625b1b4caaa7bad51d9003f8b07a468a704e0644a700e936c357c17dd45a", size = 38766 },
+    { url = "https://files.pythonhosted.org/packages/89/e2/8c299f384ae4364193724e2adad99f9504599d02a73ec9199bf3f406549d/wrapt-1.17.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f2a28eb35cf99d5f5bd12f5dd44a0f41d206db226535b37b0c60e9da162c3ed", size = 83730 },
+    { url = "https://files.pythonhosted.org/packages/29/ef/fcdb776b12df5ea7180d065b28fa6bb27ac785dddcd7202a0b6962bbdb47/wrapt-1.17.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:81b1289e99cf4bad07c23393ab447e5e96db0ab50974a280f7954b071d41b489", size = 75470 },
+    { url = "https://files.pythonhosted.org/packages/55/b5/698bd0bf9fbb3ddb3a2feefbb7ad0dea1205f5d7d05b9cbab54f5db731aa/wrapt-1.17.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f2939cd4a2a52ca32bc0b359015718472d7f6de870760342e7ba295be9ebaf9", size = 83168 },
+    { url = "https://files.pythonhosted.org/packages/ce/07/701a5cee28cb4d5df030d4b2649319e36f3d9fdd8000ef1d84eb06b9860d/wrapt-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6a9653131bda68a1f029c52157fd81e11f07d485df55410401f745007bd6d339", size = 82307 },
+    { url = "https://files.pythonhosted.org/packages/42/92/c48ba92cda6f74cb914dc3c5bba9650dc80b790e121c4b987f3a46b028f5/wrapt-1.17.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4e4b4385363de9052dac1a67bfb535c376f3d19c238b5f36bddc95efae15e12d", size = 75101 },
+    { url = "https://files.pythonhosted.org/packages/8a/0a/9276d3269334138b88a2947efaaf6335f61d547698e50dff672ade24f2c6/wrapt-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bdf62d25234290db1837875d4dceb2151e4ea7f9fff2ed41c0fde23ed542eb5b", size = 81835 },
+    { url = "https://files.pythonhosted.org/packages/b9/4c/39595e692753ef656ea94b51382cc9aea662fef59d7910128f5906486f0e/wrapt-1.17.0-cp311-cp311-win32.whl", hash = "sha256:5d8fd17635b262448ab8f99230fe4dac991af1dabdbb92f7a70a6afac8a7e346", size = 36412 },
+    { url = "https://files.pythonhosted.org/packages/63/bb/c293a67fb765a2ada48f48cd0f2bb957da8161439da4c03ea123b9894c02/wrapt-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:92a3d214d5e53cb1db8b015f30d544bc9d3f7179a05feb8f16df713cecc2620a", size = 38744 },
+    { url = "https://files.pythonhosted.org/packages/85/82/518605474beafff11f1a34759f6410ab429abff9f7881858a447e0d20712/wrapt-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:89fc28495896097622c3fc238915c79365dd0ede02f9a82ce436b13bd0ab7569", size = 38904 },
+    { url = "https://files.pythonhosted.org/packages/80/6c/17c3b2fed28edfd96d8417c865ef0b4c955dc52c4e375d86f459f14340f1/wrapt-1.17.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:875d240fdbdbe9e11f9831901fb8719da0bd4e6131f83aa9f69b96d18fae7504", size = 88622 },
+    { url = "https://files.pythonhosted.org/packages/4a/11/60ecdf3b0fd3dca18978d89acb5d095a05f23299216e925fcd2717c81d93/wrapt-1.17.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5ed16d95fd142e9c72b6c10b06514ad30e846a0d0917ab406186541fe68b451", size = 80920 },
+    { url = "https://files.pythonhosted.org/packages/d2/50/dbef1a651578a3520d4534c1e434989e3620380c1ad97e309576b47f0ada/wrapt-1.17.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18b956061b8db634120b58f668592a772e87e2e78bc1f6a906cfcaa0cc7991c1", size = 89170 },
+    { url = "https://files.pythonhosted.org/packages/44/a2/78c5956bf39955288c9e0dd62e807b308c3aa15a0f611fbff52aa8d6b5ea/wrapt-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:daba396199399ccabafbfc509037ac635a6bc18510ad1add8fd16d4739cdd106", size = 86748 },
+    { url = "https://files.pythonhosted.org/packages/99/49/2ee413c78fc0bdfebe5bee590bf3becdc1fab0096a7a9c3b5c9666b2415f/wrapt-1.17.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4d63f4d446e10ad19ed01188d6c1e1bb134cde8c18b0aa2acfd973d41fcc5ada", size = 79734 },
+    { url = "https://files.pythonhosted.org/packages/c0/8c/4221b7b270e36be90f0930fe15a4755a6ea24093f90b510166e9ed7861ea/wrapt-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8a5e7cc39a45fc430af1aefc4d77ee6bad72c5bcdb1322cfde852c15192b8bd4", size = 87552 },
+    { url = "https://files.pythonhosted.org/packages/4c/6b/1aaccf3efe58eb95e10ce8e77c8909b7a6b0da93449a92c4e6d6d10b3a3d/wrapt-1.17.0-cp312-cp312-win32.whl", hash = "sha256:0a0a1a1ec28b641f2a3a2c35cbe86c00051c04fffcfcc577ffcdd707df3f8635", size = 36647 },
+    { url = "https://files.pythonhosted.org/packages/b3/4f/243f88ac49df005b9129194c6511b3642818b3e6271ddea47a15e2ee4934/wrapt-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:3c34f6896a01b84bab196f7119770fd8466c8ae3dfa73c59c0bb281e7b588ce7", size = 38830 },
+    { url = "https://files.pythonhosted.org/packages/67/9c/38294e1bb92b055222d1b8b6591604ca4468b77b1250f59c15256437644f/wrapt-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:714c12485aa52efbc0fc0ade1e9ab3a70343db82627f90f2ecbc898fdf0bb181", size = 38904 },
+    { url = "https://files.pythonhosted.org/packages/78/b6/76597fb362cbf8913a481d41b14b049a8813cd402a5d2f84e57957c813ae/wrapt-1.17.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da427d311782324a376cacb47c1a4adc43f99fd9d996ffc1b3e8529c4074d393", size = 88608 },
+    { url = "https://files.pythonhosted.org/packages/bc/69/b500884e45b3881926b5f69188dc542fb5880019d15c8a0df1ab1dfda1f7/wrapt-1.17.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba1739fb38441a27a676f4de4123d3e858e494fac05868b7a281c0a383c098f4", size = 80879 },
+    { url = "https://files.pythonhosted.org/packages/52/31/f4cc58afe29eab8a50ac5969963010c8b60987e719c478a5024bce39bc42/wrapt-1.17.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e711fc1acc7468463bc084d1b68561e40d1eaa135d8c509a65dd534403d83d7b", size = 89119 },
+    { url = "https://files.pythonhosted.org/packages/aa/9c/05ab6bf75dbae7a9d34975fb6ee577e086c1c26cde3b6cf6051726d33c7c/wrapt-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:140ea00c87fafc42739bd74a94a5a9003f8e72c27c47cd4f61d8e05e6dec8721", size = 86778 },
+    { url = "https://files.pythonhosted.org/packages/0e/6c/4b8d42e3db355603d35fe5c9db79c28f2472a6fd1ccf4dc25ae46739672a/wrapt-1.17.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:73a96fd11d2b2e77d623a7f26e004cc31f131a365add1ce1ce9a19e55a1eef90", size = 79793 },
+    { url = "https://files.pythonhosted.org/packages/69/23/90e3a2ee210c0843b2c2a49b3b97ffcf9cad1387cb18cbeef9218631ed5a/wrapt-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0b48554952f0f387984da81ccfa73b62e52817a4386d070c75e4db7d43a28c4a", size = 87606 },
+    { url = "https://files.pythonhosted.org/packages/5f/06/3683126491ca787d8d71d8d340e775d40767c5efedb35039d987203393b7/wrapt-1.17.0-cp313-cp313-win32.whl", hash = "sha256:498fec8da10e3e62edd1e7368f4b24aa362ac0ad931e678332d1b209aec93045", size = 36651 },
+    { url = "https://files.pythonhosted.org/packages/f1/bc/3bf6d2ca0d2c030d324ef9272bea0a8fdaff68f3d1fa7be7a61da88e51f7/wrapt-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:fd136bb85f4568fffca995bd3c8d52080b1e5b225dbf1c2b17b66b4c5fa02838", size = 38835 },
+    { url = "https://files.pythonhosted.org/packages/ce/b5/251165c232d87197a81cd362eeb5104d661a2dd3aa1f0b33e4bf61dda8b8/wrapt-1.17.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:17fcf043d0b4724858f25b8826c36e08f9fb2e475410bece0ec44a22d533da9b", size = 40146 },
+    { url = "https://files.pythonhosted.org/packages/89/33/1e1bdd3e866eeb73d8c4755db1ceb8a80d5bd51ee4648b3f2247adec4e67/wrapt-1.17.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4a557d97f12813dc5e18dad9fa765ae44ddd56a672bb5de4825527c847d6379", size = 113444 },
+    { url = "https://files.pythonhosted.org/packages/9f/7c/94f53b065a43f5dc1fbdd8b80fd8f41284315b543805c956619c0b8d92f0/wrapt-1.17.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0229b247b0fc7dee0d36176cbb79dbaf2a9eb7ecc50ec3121f40ef443155fb1d", size = 101246 },
+    { url = "https://files.pythonhosted.org/packages/62/5d/640360baac6ea6018ed5e34e6e80e33cfbae2aefde24f117587cd5efd4b7/wrapt-1.17.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8425cfce27b8b20c9b89d77fb50e368d8306a90bf2b6eef2cdf5cd5083adf83f", size = 109320 },
+    { url = "https://files.pythonhosted.org/packages/e3/cf/6c7a00ae86a2e9482c91170aefe93f4ccda06c1ac86c4de637c69133da59/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9c900108df470060174108012de06d45f514aa4ec21a191e7ab42988ff42a86c", size = 110193 },
+    { url = "https://files.pythonhosted.org/packages/cd/cc/aa718df0d20287e8f953ce0e2f70c0af0fba1d3c367db7ee8bdc46ea7003/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:4e547b447073fc0dbfcbff15154c1be8823d10dab4ad401bdb1575e3fdedff1b", size = 100460 },
+    { url = "https://files.pythonhosted.org/packages/f7/16/9f3ac99fe1f6caaa789d67b4e3c562898b532c250769f5255fa8b8b93983/wrapt-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:914f66f3b6fc7b915d46c1cc424bc2441841083de01b90f9e81109c9759e43ab", size = 106347 },
+    { url = "https://files.pythonhosted.org/packages/64/85/c77a331b2c06af49a687f8b926fc2d111047a51e6f0b0a4baa01ff3a673a/wrapt-1.17.0-cp313-cp313t-win32.whl", hash = "sha256:a4192b45dff127c7d69b3bdfb4d3e47b64179a0b9900b6351859f3001397dabf", size = 37971 },
+    { url = "https://files.pythonhosted.org/packages/05/9b/b2469f8be9efed24283fd7b9eeb8e913e9bc0715cf919ea8645e428ab7af/wrapt-1.17.0-cp313-cp313t-win_amd64.whl", hash = "sha256:4f643df3d4419ea3f856c5c3f40fec1d65ea2e89ec812c83f7767c8730f9827a", size = 40755 },
+    { url = "https://files.pythonhosted.org/packages/4b/d9/a8ba5e9507a9af1917285d118388c5eb7a81834873f45df213a6fe923774/wrapt-1.17.0-py3-none-any.whl", hash = "sha256:d2c63b93548eda58abf5188e505ffed0229bf675f7c3090f8e36ad55b8cbc371", size = 23592 },
+]
+
+[[package]]
+name = "yarl"
+version = "1.15.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/e1/d5427a061819c9f885f58bb0467d02a523f1aec19f9e5f9c82ce950d90d3/yarl-1.15.2.tar.gz", hash = "sha256:a39c36f4218a5bb668b4f06874d676d35a035ee668e6e7e3538835c703634b84", size = 169318 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/59/3ae125c97a2a8571ea16fdf59fcbd288bc169e0005d1af9946a90ea831d9/yarl-1.15.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9fcda20b2de7042cc35cf911702fa3d8311bd40055a14446c1e62403684afdc5", size = 136492 },
+    { url = "https://files.pythonhosted.org/packages/f9/2b/efa58f36b582db45b94c15e87803b775eb8a4ca0db558121a272e67f3564/yarl-1.15.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0545de8c688fbbf3088f9e8b801157923be4bf8e7b03e97c2ecd4dfa39e48e0e", size = 88614 },
+    { url = "https://files.pythonhosted.org/packages/82/69/eb73c0453a2ff53194df485dc7427d54e6cb8d1180fcef53251a8e24d069/yarl-1.15.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fbda058a9a68bec347962595f50546a8a4a34fd7b0654a7b9697917dc2bf810d", size = 86607 },
+    { url = "https://files.pythonhosted.org/packages/48/4e/89beaee3a4da0d1c6af1176d738cff415ff2ad3737785ee25382409fe3e3/yarl-1.15.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1ac2bc069f4a458634c26b101c2341b18da85cb96afe0015990507efec2e417", size = 334077 },
+    { url = "https://files.pythonhosted.org/packages/da/e8/8fcaa7552093f94c3f327783e2171da0eaa71db0c267510898a575066b0f/yarl-1.15.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd126498171f752dd85737ab1544329a4520c53eed3997f9b08aefbafb1cc53b", size = 347365 },
+    { url = "https://files.pythonhosted.org/packages/be/fa/dc2002f82a89feab13a783d3e6b915a3a2e0e83314d9e3f6d845ee31bfcc/yarl-1.15.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3db817b4e95eb05c362e3b45dafe7144b18603e1211f4a5b36eb9522ecc62bcf", size = 344823 },
+    { url = "https://files.pythonhosted.org/packages/ae/c8/c4a00fe7f2aa6970c2651df332a14c88f8baaedb2e32d6c3b8c8a003ea74/yarl-1.15.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:076b1ed2ac819933895b1a000904f62d615fe4533a5cf3e052ff9a1da560575c", size = 337132 },
+    { url = "https://files.pythonhosted.org/packages/07/bf/84125f85f44bf2af03f3cf64e87214b42cd59dcc8a04960d610a9825f4d4/yarl-1.15.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f8cfd847e6b9ecf9f2f2531c8427035f291ec286c0a4944b0a9fce58c6446046", size = 326258 },
+    { url = "https://files.pythonhosted.org/packages/00/19/73ad8122b2fa73fe22e32c24b82a6c053cf6c73e2f649b73f7ef97bee8d0/yarl-1.15.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:32b66be100ac5739065496c74c4b7f3015cef792c3174982809274d7e51b3e04", size = 336212 },
+    { url = "https://files.pythonhosted.org/packages/39/1d/2fa4337d11f6587e9b7565f84eba549f2921494bc8b10bfe811079acaa70/yarl-1.15.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:34a2d76a1984cac04ff8b1bfc939ec9dc0914821264d4a9c8fd0ed6aa8d4cfd2", size = 330397 },
+    { url = "https://files.pythonhosted.org/packages/39/ab/dce75e06806bcb4305966471ead03ce639d8230f4f52c32bd614d820c044/yarl-1.15.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0afad2cd484908f472c8fe2e8ef499facee54a0a6978be0e0cff67b1254fd747", size = 334985 },
+    { url = "https://files.pythonhosted.org/packages/c1/98/3f679149347a5e34c952bf8f71a387bc96b3488fae81399a49f8b1a01134/yarl-1.15.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c68e820879ff39992c7f148113b46efcd6ec765a4865581f2902b3c43a5f4bbb", size = 356033 },
+    { url = "https://files.pythonhosted.org/packages/f7/8c/96546061c19852d0a4b1b07084a58c2e8911db6bcf7838972cff542e09fb/yarl-1.15.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:98f68df80ec6ca3015186b2677c208c096d646ef37bbf8b49764ab4a38183931", size = 357710 },
+    { url = "https://files.pythonhosted.org/packages/01/45/ade6fb3daf689816ebaddb3175c962731edf300425c3254c559b6d0dcc27/yarl-1.15.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3c56ec1eacd0a5d35b8a29f468659c47f4fe61b2cab948ca756c39b7617f0aa5", size = 345532 },
+    { url = "https://files.pythonhosted.org/packages/e7/d7/8de800d3aecda0e64c43e8fc844f7effc8731a6099fa0c055738a2247504/yarl-1.15.2-cp311-cp311-win32.whl", hash = "sha256:eedc3f247ee7b3808ea07205f3e7d7879bc19ad3e6222195cd5fbf9988853e4d", size = 78250 },
+    { url = "https://files.pythonhosted.org/packages/3a/6c/69058bbcfb0164f221aa30e0cd1a250f6babb01221e27c95058c51c498ca/yarl-1.15.2-cp311-cp311-win_amd64.whl", hash = "sha256:0ccaa1bc98751fbfcf53dc8dfdb90d96e98838010fc254180dd6707a6e8bb179", size = 84492 },
+    { url = "https://files.pythonhosted.org/packages/e0/d1/17ff90e7e5b1a0b4ddad847f9ec6a214b87905e3a59d01bff9207ce2253b/yarl-1.15.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:82d5161e8cb8f36ec778fd7ac4d740415d84030f5b9ef8fe4da54784a1f46c94", size = 136721 },
+    { url = "https://files.pythonhosted.org/packages/44/50/a64ca0577aeb9507f4b672f9c833d46cf8f1e042ce2e80c11753b936457d/yarl-1.15.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa2bea05ff0a8fb4d8124498e00e02398f06d23cdadd0fe027d84a3f7afde31e", size = 88954 },
+    { url = "https://files.pythonhosted.org/packages/c9/0a/a30d0b02046d4088c1fd32d85d025bd70ceb55f441213dee14d503694f41/yarl-1.15.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:99e12d2bf587b44deb74e0d6170fec37adb489964dbca656ec41a7cd8f2ff178", size = 86692 },
+    { url = "https://files.pythonhosted.org/packages/06/0b/7613decb8baa26cba840d7ea2074bd3c5e27684cbcb6d06e7840d6c5226c/yarl-1.15.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:243fbbbf003754fe41b5bdf10ce1e7f80bcc70732b5b54222c124d6b4c2ab31c", size = 325762 },
+    { url = "https://files.pythonhosted.org/packages/97/f5/b8c389a58d1eb08f89341fc1bbcc23a0341f7372185a0a0704dbdadba53a/yarl-1.15.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:856b7f1a7b98a8c31823285786bd566cf06226ac4f38b3ef462f593c608a9bd6", size = 335037 },
+    { url = "https://files.pythonhosted.org/packages/cb/f9/d89b93a7bb8b66e01bf722dcc6fec15e11946e649e71414fd532b05c4d5d/yarl-1.15.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:553dad9af802a9ad1a6525e7528152a015b85fb8dbf764ebfc755c695f488367", size = 334221 },
+    { url = "https://files.pythonhosted.org/packages/10/77/1db077601998e0831a540a690dcb0f450c31f64c492e993e2eaadfbc7d31/yarl-1.15.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30c3ff305f6e06650a761c4393666f77384f1cc6c5c0251965d6bfa5fbc88f7f", size = 330167 },
+    { url = "https://files.pythonhosted.org/packages/3b/c2/e5b7121662fd758656784fffcff2e411c593ec46dc9ec68e0859a2ffaee3/yarl-1.15.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:353665775be69bbfc6d54c8d134bfc533e332149faeddd631b0bc79df0897f46", size = 317472 },
+    { url = "https://files.pythonhosted.org/packages/c6/f3/41e366c17e50782651b192ba06a71d53500cc351547816bf1928fb043c4f/yarl-1.15.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f4fe99ce44128c71233d0d72152db31ca119711dfc5f2c82385ad611d8d7f897", size = 330896 },
+    { url = "https://files.pythonhosted.org/packages/79/a2/d72e501bc1e33e68a5a31f584fe4556ab71a50a27bfd607d023f097cc9bb/yarl-1.15.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:9c1e3ff4b89cdd2e1a24c214f141e848b9e0451f08d7d4963cb4108d4d798f1f", size = 328787 },
+    { url = "https://files.pythonhosted.org/packages/9d/ba/890f7e1ea17f3c247748548eee876528ceb939e44566fa7d53baee57e5aa/yarl-1.15.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:711bdfae4e699a6d4f371137cbe9e740dc958530cb920eb6f43ff9551e17cfbc", size = 332631 },
+    { url = "https://files.pythonhosted.org/packages/48/c7/27b34206fd5dfe76b2caa08bf22f9212b2d665d5bb2df8a6dd3af498dcf4/yarl-1.15.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4388c72174868884f76affcdd3656544c426407e0043c89b684d22fb265e04a5", size = 344023 },
+    { url = "https://files.pythonhosted.org/packages/88/e7/730b130f4f02bd8b00479baf9a57fdea1dc927436ed1d6ba08fa5c36c68e/yarl-1.15.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:f0e1844ad47c7bd5d6fa784f1d4accc5f4168b48999303a868fe0f8597bde715", size = 352290 },
+    { url = "https://files.pythonhosted.org/packages/84/9b/e8dda28f91a0af67098cddd455e6b540d3f682dda4c0de224215a57dee4a/yarl-1.15.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a5cafb02cf097a82d74403f7e0b6b9df3ffbfe8edf9415ea816314711764a27b", size = 343742 },
+    { url = "https://files.pythonhosted.org/packages/66/47/b1c6bb85f2b66decbe189e27fcc956ab74670a068655df30ef9a2e15c379/yarl-1.15.2-cp312-cp312-win32.whl", hash = "sha256:156ececdf636143f508770bf8a3a0498de64da5abd890c7dbb42ca9e3b6c05b8", size = 78051 },
+    { url = "https://files.pythonhosted.org/packages/7d/9e/1a897e5248ec53e96e9f15b3e6928efd5e75d322c6cf666f55c1c063e5c9/yarl-1.15.2-cp312-cp312-win_amd64.whl", hash = "sha256:435aca062444a7f0c884861d2e3ea79883bd1cd19d0a381928b69ae1b85bc51d", size = 84313 },
+    { url = "https://files.pythonhosted.org/packages/46/ab/be3229898d7eb1149e6ba7fe44f873cf054d275a00b326f2a858c9ff7175/yarl-1.15.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:416f2e3beaeae81e2f7a45dc711258be5bdc79c940a9a270b266c0bec038fb84", size = 135006 },
+    { url = "https://files.pythonhosted.org/packages/10/10/b91c186b1b0e63951f80481b3e6879bb9f7179d471fe7c4440c9e900e2a3/yarl-1.15.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:173563f3696124372831007e3d4b9821746964a95968628f7075d9231ac6bb33", size = 88121 },
+    { url = "https://files.pythonhosted.org/packages/bf/1d/4ceaccf836b9591abfde775e84249b847ac4c6c14ee2dd8d15b5b3cede44/yarl-1.15.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9ce2e0f6123a60bd1a7f5ae3b2c49b240c12c132847f17aa990b841a417598a2", size = 85967 },
+    { url = "https://files.pythonhosted.org/packages/93/bd/c924f22bdb2c5d0ca03a9e64ecc5e041aace138c2a91afff7e2f01edc3a1/yarl-1.15.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eaea112aed589131f73d50d570a6864728bd7c0c66ef6c9154ed7b59f24da611", size = 325615 },
+    { url = "https://files.pythonhosted.org/packages/59/a5/6226accd5c01cafd57af0d249c7cf9dd12569cd9c78fbd93e8198e7a9d84/yarl-1.15.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e4ca3b9f370f218cc2a0309542cab8d0acdfd66667e7c37d04d617012485f904", size = 334945 },
+    { url = "https://files.pythonhosted.org/packages/4c/c1/cc6ccdd2bcd0ff7291602d5831754595260f8d2754642dfd34fef1791059/yarl-1.15.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23ec1d3c31882b2a8a69c801ef58ebf7bae2553211ebbddf04235be275a38548", size = 336701 },
+    { url = "https://files.pythonhosted.org/packages/ef/ff/39a767ee249444e4b26ea998a526838238f8994c8f274befc1f94dacfb43/yarl-1.15.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75119badf45f7183e10e348edff5a76a94dc19ba9287d94001ff05e81475967b", size = 330977 },
+    { url = "https://files.pythonhosted.org/packages/dd/ba/b1fed73f9d39e3e7be8f6786be5a2ab4399c21504c9168c3cadf6e441c2e/yarl-1.15.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78e6fdc976ec966b99e4daa3812fac0274cc28cd2b24b0d92462e2e5ef90d368", size = 317402 },
+    { url = "https://files.pythonhosted.org/packages/82/e8/03e3ebb7f558374f29c04868b20ca484d7997f80a0a191490790a8c28058/yarl-1.15.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8657d3f37f781d987037f9cc20bbc8b40425fa14380c87da0cb8dfce7c92d0fb", size = 331776 },
+    { url = "https://files.pythonhosted.org/packages/1f/83/90b0f4fd1ecf2602ba4ac50ad0bbc463122208f52dd13f152bbc0d8417dd/yarl-1.15.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:93bed8a8084544c6efe8856c362af08a23e959340c87a95687fdbe9c9f280c8b", size = 331585 },
+    { url = "https://files.pythonhosted.org/packages/c7/f6/1ed7e7f270ae5f9f1174c1f8597b29658f552fee101c26de8b2eb4ca147a/yarl-1.15.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:69d5856d526802cbda768d3e6246cd0d77450fa2a4bc2ea0ea14f0d972c2894b", size = 336395 },
+    { url = "https://files.pythonhosted.org/packages/e0/3a/4354ed8812909d9ec54a92716a53259b09e6b664209231f2ec5e75f4820d/yarl-1.15.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:ccad2800dfdff34392448c4bf834be124f10a5bc102f254521d931c1c53c455a", size = 342810 },
+    { url = "https://files.pythonhosted.org/packages/de/cc/39e55e16b1415a87f6d300064965d6cfb2ac8571e11339ccb7dada2444d9/yarl-1.15.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:a880372e2e5dbb9258a4e8ff43f13888039abb9dd6d515f28611c54361bc5644", size = 351441 },
+    { url = "https://files.pythonhosted.org/packages/fb/19/5cd4757079dc9d9f3de3e3831719b695f709a8ce029e70b33350c9d082a7/yarl-1.15.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c998d0558805860503bc3a595994895ca0f7835e00668dadc673bbf7f5fbfcbe", size = 345875 },
+    { url = "https://files.pythonhosted.org/packages/83/a0/ef09b54634f73417f1ea4a746456a4372c1b044f07b26e16fa241bd2d94e/yarl-1.15.2-cp313-cp313-win32.whl", hash = "sha256:533a28754e7f7439f217550a497bb026c54072dbe16402b183fdbca2431935a9", size = 302609 },
+    { url = "https://files.pythonhosted.org/packages/20/9f/f39c37c17929d3975da84c737b96b606b68c495cc4ee86408f10523a1635/yarl-1.15.2-cp313-cp313-win_amd64.whl", hash = "sha256:5838f2b79dc8f96fdc44077c9e4e2e33d7089b10788464609df788eb97d03aad", size = 308252 },
+    { url = "https://files.pythonhosted.org/packages/46/cf/a28c494decc9c8776b0d7b729c68d26fdafefcedd8d2eab5d9cd767376b2/yarl-1.15.2-py3-none-any.whl", hash = "sha256:0d3105efab7c5c091609abacad33afff33bdff0035bece164c98bcf5a85ef90a", size = 38891 },
+]