Merge pull request #274 from specklesystems/jrm/no-deps

fix(pip): install

.circleci/config.yml

@@ -1,17 +1,331 @@
 version: 2.1
 
-# Define the jobs we want to run for this project
-jobs:
-  build:
-    docker:
-      - image: cimg/base:2023.03
-    steps:
-      - run: echo "so long and thanks for all the fish"
+orbs:
+  win: circleci/windows@5.0.0
+
+jobs:
+  package-connector:
+    docker:
+      - image: cimg/python:3.11.12
+    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.12
+    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:2025.04
+    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\smctl.exe windows certsync
+            - 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:2025.04
+    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 >>
 
-# Orchestrate our job run sequence
 workflows:
-  build_and_test:
-    when:
-      false
+  build: # build the installers, but don't persist to workspace for deployment
     jobs:
-      - build
+      - 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

.github/workflows/close-issue.yml

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

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

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

@@ -1,96 +0,0 @@
-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: main
-          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,5 +13,4 @@ Installers/
 modules/
 .tool-versions
 requirements.txt
-SEMVER
-dui3/
+SEMVER

README.md

@@ -1,73 +1,63 @@
-<h1 align="center">
+<<h1 align="center">
   <img src="https://user-images.githubusercontent.com/2679513/131189167-18ea5fe1-c578-47f6-9785-3748178e4312.png" width="150px"/><br/>
   Speckle | Blender
 </h1>
-<h3 align="center">
-    Connector for Blender
-</h3>
-<p align="center"><b>Speckle</b> is the data infrastructure for the AEC industry.</p><br/>
 
 <p align="center"><a href="https://twitter.com/SpeckleSystems"><img src="https://img.shields.io/twitter/follow/SpeckleSystems?style=social" alt="Twitter Follow"></a> <a href="https://speckle.community"><img src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fspeckle.community&amp;style=flat-square&amp;logo=discourse&amp;logoColor=white" alt="Community forum users"></a> <a href="https://speckle.systems"><img src="https://img.shields.io/badge/https://-speckle.systems-royalblue?style=flat-square" alt="website"></a> <a href="https://speckle.guide/dev/"><img src="https://img.shields.io/badge/docs-speckle.guide-orange?style=flat-square&amp;logo=read-the-docs&amp;logoColor=white" alt="docs"></a></p>
-<p align="center"><a href="https://github.com/specklesystems/speckle-blender/"><img src="https://circleci.com/gh/specklesystems/speckle-blender.svg?style=svg&amp;circle-token=76eabd350ea243575cbb258b746ed3f471f7ac29" alt="Speckle-Next"></a> </p>
 
-# About Speckle
+> Speckle is the first AEC data hub that connects with your favorite AEC tools. Speckle exists to overcome the challenges of working in a fragmented industry where communication, creative workflows, and the exchange of data are often hindered by siloed software and processes. It is here to make the industry better.
 
-What is Speckle? Check our ![YouTube Video Views](https://img.shields.io/youtube/views/B9humiSpHzM?label=Speckle%20in%201%20minute%20video&style=social)
-
-### Features
-
-- **Object-based:** say goodbye to files! Speckle is the first object based platform for the AEC industry
-- **Version control:** Speckle is the Git & Hub for geometry and BIM data
-- **Collaboration:** share your designs collaborate with others
-- **3D Viewer:** see your CAD and BIM models online, share and embed them anywhere
-- **Interoperability:** get your CAD and BIM models into other software without exporting or importing
-- **Real time:** get real time updates and notifications and changes
-- **GraphQL API:** get what you need anywhere you want it
-- **Webhooks:** the base for a automation and next-gen pipelines
-- **Built for developers:** we are building Speckle with developers in mind and got tools for every stack
-- **Built for the AEC industry:** Speckle connectors are plugins for the most common software used in the industry such as Revit, Rhino, Grasshopper, AutoCAD, Civil 3D, Excel, Unreal Engine, Unity, QGIS, Blender and more!
-
-### Try Speckle now!
-
-Give Speckle a try in no time by:
-
-- [![speckle XYZ](https://img.shields.io/badge/https://-speckle.xyz-0069ff?style=flat-square&logo=hackthebox&logoColor=white)](https://speckle.xyz) ⇒ creating an account at our public server
-- [![create a droplet](https://img.shields.io/badge/Create%20a%20Droplet-0069ff?style=flat-square&logo=digitalocean&logoColor=white)](https://marketplace.digitalocean.com/apps/speckle-server?refcode=947a2b5d7dc1) ⇒ deploying an instance in 1 click 
-
-### Resources
-
-- [![Community forum users](https://img.shields.io/badge/community-forum-green?style=for-the-badge&logo=discourse&logoColor=white)](https://speckle.community) for help, feature requests or just to hang with other speckle enthusiasts, check out our community forum!
-- [![website](https://img.shields.io/badge/tutorials-speckle.systems-royalblue?style=for-the-badge&logo=youtube)](https://speckle.systems) our tutorials portal is full of resources to get you started using Speckle
-- [![docs](https://img.shields.io/badge/docs-speckle.guide-orange?style=for-the-badge&logo=read-the-docs&logoColor=white)](https://speckle.guide/user/blender.html) reference on almost any end-user and developer functionality
+<h3 align="center">
+    Speckle Connector for Blender
+</h3>
 
+> [!WARNING]
+> This is a legacy repo! A new next generation connector will be coming soon. In the meantime, check out our active next generation repos here 👇<br/>
+> [`speckle-sharp-connectors`](https://github.com/specklesystems/speckle-sharp-connectors): our .NET next generation connectors and desktop UI<br/>
+> [`speckle-sharp-sdk`](https://github.com/specklesystems/speckle-sharp-sdk): our .NET SDK, Tests, and Objects
 
 # Blender Connector
 
 The Speckle UI can be found in the 3d viewport toolbar (N), under the Speckle tab.
 
+Head to the [**📚 documentation**](https://speckle.guide/user/blender.html) for more information.
 
 ## Installation
-We officially support Blender 4.2 and newer, on Windows.
+
+We officially support Blender 3.3 and newer, on Windows and Mac.
+
+Please follow our installation instructions on our [connector docs](https://speckle.guide/user/blender.html#installation)
 
 ## Usage
 Once enabled in `Preferences -> Addons`,
 The Speckle connector UI can be found in the 3d viewport toolbar (N), under the `Speckle` tab.
 
-- Available user accounts are automatically detected and made available.
-- Select the account from the dropdown list in the `Accounts` panel. This will populate the `Projects` list with available projects for the selected user account.
+- Available user accounts are automatically detected and made available. To add user accounts use **Speckle Manager**.
+- Select the user from the dropdown list in the `Users` panel. This will populate the `Projects` list with available projects for the selected user account.
 - Select a model and version from the dropdown menus.
-- Click on `Load` to download and convert the objects from the selected model version. The objects will be linked into a Blender Collection.
+- Click on `Receive` to download and convert the objects from the selected model version. The objects will be linked into a Blender Collection, named `<PROJECT_NAME> [ <MODEL_NAME> @ <VERSION_ID> ]`.
 - Click on `Open Model in Web` to view the model in your web browser.
 
 ## Supported Elements
 
 The Blender Connector is still a work in progress and, as such, data sent from the Blender connector is a highly lossy exchange. Our connectors are ever evolving to facilitate more and more Speckle usecases. We welcome feedback, requests, edge cases, and contributions!
 
+The full matrix of supported Blender and Speckle types [can be found here](https://speckle.guide/user/support-tables.html#blender)
+
+
+## Additional Features
+
+- Speckle properties will be imported as custom properties on Blender objects. Nested dictionaries are expanded to individual properties by flattening their key hierarchy. I.e. `propA:{'propB': {'propC':10, 'propD':'foobar'}}` is flattened to `propA.propB.propC = 10` and `propA.propB.propD = "foobar"`.
+
+- If a `renderMaterial` property is found, **SpeckleBlender** will create a material named using the sub-property `renderMaterial.name`. If a material with that name already exists in Blender, **SpeckleBlender** will just assign that existing material to the object. This allows geometry to be updated without having to re-assign and re-create materials.
+
+- Receiving vertex colors is supported. The `colors` list from Speckle meshes is translated to a vertex color layer.
+
+- Receive/Send scripts. Allow injecting a custom python function to the receive/send process to automate any blender operations
 
 ## 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.
-
+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.
 As such, an internet connection is required for first launch of the connector.
 

bpy_speckle/__init__.py

@@ -1,146 +1,114 @@
-# 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.types import WindowManager
-from .connector.ui import icons
-import json
 
-# Ensure dependencies
-from .installer import ensure_dependencies
+from bpy_speckle.installer import ensure_dependencies
+
 ensure_dependencies(f"Blender {bpy.app.version[0]}.{bpy.app.version[1]}")
 
+from bpy.app.handlers import persistent
+from specklepy.logging import metrics
+
+from bpy_speckle.callbacks import *
+from bpy_speckle.operators import *
+from bpy_speckle.properties import *
+from bpy_speckle.ui import *
+
 bl_info = {
-    "name": "Speckle Blender ",
+    "name": "SpeckleBlender 2.0 (Legacy)",
     "author": "Speckle Systems",
-    "version": (3, 999, 999),
-    "blender": (4, 2, 0),
+    "version": (0, 2, 0),
+    "blender": (2, 92, 0),
     "location": "3d viewport toolbar (N), under the Speckle tab.",
-    "description": "The Speckle Connector using specklepy 3.x!",
-    "warning": "This add-on is WIP and should be used with caution",
+    "description": "(Legacy) Speckle Connector using specklepy 2.0!",
+    "warning": "This is a legacy add-on. Download the new connector from https://app.speckle.systems/connectors",
     "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
+"""
 
-def invoke_window_manager_properties():
-    # Accounts
-    WindowManager.speckle_accounts = bpy.props.CollectionProperty(
-        type = speckle_account
-    )
-    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()
-
-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)
-
-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)
+"""
+Add load handler to initialize Speckle when 
+loading a Blender file
+"""
 
 
-# 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
+@persistent
 def load_handler(dummy):
-    load_model_cards(bpy.context.scene)
+    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)
 
-@bpy.app.handlers.persistent
-def save_handler(dummy):
-    save_model_cards(bpy.context.scene)
 
-# Register and Unregister
 def register():
-    icons.load_icons()
+    from bpy.utils import register_class
 
-    for cls in classes:
-        bpy.utils.register_class(cls)
-    register_speckle_state() # Register SpeckleState
+    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
+    )
+    bpy.types.Object.speckle = bpy.props.PointerProperty(type=SpeckleObjectSettings)
+
+    """
+    Add callbacks
+    """
+
+    # 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
+    #     ))
 
     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)
 
-# Run the register function when the script is executed
+    """
+    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)
+
+
 if __name__ == "__main__":
     register()

bpy_speckle/blender_commit_object_builder.py

@@ -0,0 +1,140 @@
+from typing import Dict, Optional, Union
+
+import bpy
+from attrs import define
+from bpy.types import ID, Collection, Object
+from specklepy.objects.base import Base
+from specklepy.objects.graph_traversal.commit_object_builder import (
+    ROOT,
+    CommitObjectBuilder,
+)
+from specklepy.objects.other import Collection as SCollection
+
+from bpy_speckle.functions import _report
+
+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

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

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

bpy_speckle/callbacks/draw_speckle_info.py

@@ -0,0 +1,23 @@
+"""
+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

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

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

bpy_speckle/connector/blender_operators/__init__.py

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

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

@@ -1,107 +0,0 @@
-import bpy
-from bpy.types import Context, Event, UILayout, WindowManager
-from ..utils.account_manager import (
-    get_model_details_by_wrapper,
-    get_project_from_url,
-    can_load,
-)
-
-
-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]:
-        self.report({"INFO"}, f"Adding project from URL: {self.url}")
-
-        wm = context.window_manager
-
-        # Get project from URL
-        wrapper, client, project, error_message = get_project_from_url(self.url)
-
-        if error_message:
-            self.report({"ERROR"}, error_message)
-            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)
-
-        # Check permissions
-        can_load_permission, permission_error = can_load(client, project)
-        if not can_load_permission:
-            self.report({"ERROR"}, permission_error)
-            return {"CANCELLED"}
-
-        # Update the window manager with the selected project/model/version
-        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="")

bpy_speckle/connector/blender_operators/load_button.py

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

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

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

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

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

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

bpy_speckle/connector/operations/load_operation.py

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

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

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

bpy_speckle/connector/ui/icons.py

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

@@ -1,135 +0,0 @@
-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")
-                        split.enabled = False
-                    if model_card.load_option == "SPECIFIC":
-                        split.operator("speckle.load", text=f"{model_card.version_id}")
-                        split.enabled = False
-                    # TODO: Get last updated time
-                    split.label(text="Last updated: 2 days ago")

bpy_speckle/connector/ui/model_card.py

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

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

@@ -1,286 +0,0 @@
-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,
-)
-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
-    can_receive: bpy.props.BoolProperty(name="Can Receive", default=False)  # 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)
-            # enable/disable the row based on permission
-            row.enabled = item.can_receive
-
-            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.enabled = item.can_receive
-            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, bool]] = get_projects_for_account(
-            self.accounts, search=search, workspace_id=self.workspaces
-        )
-
-        for name, role, updated, id, can_receive in projects:
-            project: speckle_project = wm.speckle_projects.add()
-            project.name = name
-            project.role = role
-            project.updated = updated
-            project.id = id
-            project.can_receive = can_receive
-        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, bool]] = get_projects_for_account(
-            self.accounts, search=search, workspace_id=self.workspaces
-        )
-
-        for name, role, updated, id, can_receive in projects:
-            project: speckle_project = wm.speckle_projects.add()
-            project.name = name
-            project.role = role
-            project.updated = updated
-            project.id = id
-            project.can_receive = can_receive
-        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]
-
-            # verify the user has permission to receive from this project
-            if not selected_project.can_receive:
-                self.report(
-                    {"ERROR"},
-                    "Your role on this project doesn't give you permission to load.",
-                )
-                return {"CANCELLED"}
-
-            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, bool]] = get_projects_for_account(
-            selected_account_id, workspace_id=selected_workspace_id
-        )
-
-        for name, role, updated, id, can_receive in projects:
-            project: speckle_project = wm.speckle_projects.add()
-            project.name = name
-            project.role = role
-            project.updated = updated
-            project.id = id
-            project.can_receive = can_receive
-
-        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,
-        )
-
-        # if no accounts then don't show workspaces or projects list
-        if wm.selected_account_id != "NO_ACCOUNTS":
-            # 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

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

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

@@ -1,238 +0,0 @@
-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 specklepy.api.wrapper import StreamWrapper
-
-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)
-    if not account:
-        print("No accounts found > No workspaces!")
-        return [("", "")]
-    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 is 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
-
-
-def get_project_from_url(
-    url: str,
-) -> Tuple[Optional[StreamWrapper], Optional[object], Optional[object], str]:
-    """
-    get a project from a URL, handling all the client setup.
-    """
-    try:
-        wrapper = StreamWrapper(url)
-        client = wrapper.get_client()
-        client.authenticate_with_account(wrapper.get_account())
-
-        # get the stream_id (project_id) from the wrapper
-        if not wrapper.stream_id:
-            return wrapper, client, None, "Could not extract project ID from URL"
-
-        project = client.project.get(wrapper.stream_id)
-
-        if not project:
-            return wrapper, client, None, "Could not access project"
-
-        return wrapper, client, project, ""
-
-    except Exception as e:
-        return None, None, None, f"Failed to process URL: {str(e)}"
-
-
-def get_model_details_by_wrapper(
-    wrapper: StreamWrapper,
-) -> Tuple[str, str, str, str, str, str, str]:
-    """
-    extract model details from a StreamWrapper object.
-    """
-    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,
-    )
-
-
-def can_load(client, project) -> Tuple[bool, str]:
-    try:
-        permissions = client.project.get_permissions(project.id)
-
-        if permissions.can_load.authorized:
-            return True, ""
-        else:
-            return (
-                False,
-                "Your role on this project doesn't give you permission to load.",
-            )
-
-    except Exception as e:
-        error_msg = f"Failed to check permissions: {str(e)}"
-        print(error_msg)
-        return False, error_msg
-
-
-def can_publish(client, project) -> Tuple[bool, str]:
-    try:
-        permissions = client.project.get_permissions(project.id)
-
-        if permissions.can_publish.authorized:
-            return True, ""
-        else:
-            return (
-                False,
-                "Your role on this project doesn't give you permission to publish.",
-            )
-
-    except Exception as e:
-        error_msg = f"Failed to check permissions: {str(e)}"
-        print(error_msg)
-        return False, error_msg

bpy_speckle/connector/utils/get_ascendants.py

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

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

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

@@ -1,66 +0,0 @@
-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
-from .account_manager import can_load
-
-
-def get_projects_for_account(
-    account_id: str, workspace_id: str = None, search: Optional[str] = None
-) -> List[Tuple[str, str, str, str, bool]]:
-    """
-    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_query = None if personal_only else workspace_id
-
-        # set include_implicit_access to True to get all projects
-        filter = UserProjectsFilter(
-            search=search,
-            workspaceId=workspace_id_query,
-            personalOnly=personal_only,
-            include_implicit_access=True,
-        )
-
-        projects = client.active_user.get_projects(limit=10, filter=filter).items
-
-        # determine if user can receive from project based on role
-        result = []
-        for project in projects:
-            can_load_permission, _ = can_load(client, project)
-
-            result.append(
-                (
-                    strip_non_ascii(project.name),
-                    format_role(getattr(project, "role", ""))
-                    if hasattr(project, "role") and project.role
-                    else "",
-                    format_relative_time(project.updated_at),
-                    project.id,
-                    can_load_permission,
-                )
-            )
-
-        return result
-
-    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

@@ -1,100 +0,0 @@
-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,
-                version.message if version.message is not None else "No message",
-                format_relative_time(version.created_at),
-            )
-            for version in versions
-            if version.referenced_object is not None
-        ]
-
-    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,
-            latest.message if latest.message is not None else "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

@@ -0,0 +1,22 @@
+IGNORED_PROPERTY_KEYS = {
+    "id",
+    "elements",
+    "displayMesh",
+    "displayValue",
+    "speckle_type",
+    "parameters",
+    "faces",
+    "colors",
+    "vertices",
+    "renderMaterial",
+    "textureCoordinates",
+    "totalChildrenCount",
+}
+
+DISPLAY_VALUE_PROPERTY_ALIASES = {"displayValue", "@displayValue"}
+ELEMENTS_PROPERTY_ALIASES = {"elements", "@elements"}
+
+OBJECT_NAME_MAX_LENGTH = 62
+SPECKLE_ID_LENGTH = 32
+OBJECT_NAME_SPECKLE_SEPARATOR = " -- "
+OBJECT_NAME_NUMERAL_SEPARATOR = "."

bpy_speckle/convert/to_native.py

@@ -0,0 +1,975 @@
+import math
+from typing import Any, Collection, Dict, Iterable, List, Optional, Union
+
+import bmesh
+import bpy
+from bpy.types import Collection as BCollection
+from bpy.types import Object
+from mathutils import Matrix as MMatrix
+from mathutils import Quaternion as MQuaternion
+from mathutils import Vector as MVector
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import (
+    Arc,
+    Circle,
+    Curve,
+    Ellipse,
+    Line,
+    Mesh,
+    Plane,
+    Polycurve,
+    Polyline,
+)
+from specklepy.objects.other import BlockDefinition
+from specklepy.objects.other import Collection as SCollection
+from specklepy.objects.other import Instance, Transform
+
+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.convert.util import ConversionSkippedException
+from bpy_speckle.functions import _report, get_default_traversal_func, get_scale_length
+
+from .util import (
+    add_colors,
+    add_custom_properties,
+    add_faces,
+    add_to_hierarchy,
+    add_uv_coords,
+    add_vertices,
+    get_render_material,
+    get_vertex_color_material,
+    render_material_to_native,
+)
+
+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 definition.id not 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

@@ -0,0 +1,625 @@
+from typing import Dict, Iterable, List, Optional, Tuple, Union, cast
+
+import bpy
+from bpy.types import Camera as NCamera
+from bpy.types import Curve as NCurve
+from bpy.types import Depsgraph
+from bpy.types import Mesh as NMesh
+from bpy.types import MeshPolygon, Object
+from deprecated import deprecated
+from mathutils import Matrix as MMatrix
+from mathutils import Vector as MVector
+from mathutils.geometry import interpolate_bezier
+from specklepy.objects import Base
+from specklepy.objects.geometry import (
+    Box,
+    Curve,
+    Interval,
+    Mesh,
+    Point,
+    Polyline,
+    Vector,
+)
+from specklepy.objects.other import (
+    BlockDefinition,
+    BlockInstance,
+    RenderMaterial,
+    Transform,
+)
+
+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 is not 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

@@ -0,0 +1,541 @@
+import math
+from typing import Any, Dict, Optional, Tuple, Union, cast
+
+import bpy
+import idprop
+from bmesh.types import BMesh
+from bpy.types import Collection as BCollection
+from bpy.types import Material, Node, Object, ShaderNodeVertexColor
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Mesh
+from specklepy.objects.graph_traversal.traversal import TraversalContext
+from specklepy.objects.other import RenderMaterial
+
+from bpy_speckle.convert.constants import IGNORED_PROPERTY_KEYS
+from bpy_speckle.functions import _report
+
+
+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 "VERTEX_COLOR" not 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
+        _ = 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 loop in f.loops:
+                luv = loop[uv_layer]
+                luv.uv = uv[loop.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

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

bpy_speckle/converter/utils.py

@@ -1,185 +0,0 @@
-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
-    
-    # set viewport display color
-    if hasattr(render_material, "diffuse") and hasattr(render_material, "opacity"):
-        material.diffuse_color = (diffuse_rgba[0], diffuse_rgba[1], diffuse_rgba[2], opacity)
-
-    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

@@ -0,0 +1,49 @@
+from typing import Callable
+
+from specklepy.objects.base import Base
+from specklepy.objects.graph_traversal.traversal import GraphTraversal, TraversalRule
+from specklepy.objects.units import get_scale_factor_to_meters, get_units_from_string
+
+from bpy_speckle.convert.constants import ELEMENTS_PROPERTY_ALIASES
+
+
+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

@@ -1,11 +1,12 @@
 """
 Provides uniform and consistent path helpers for `specklepy`
 """
+
 import os
 import sys
+from importlib import import_module, invalidate_caches
 from pathlib import Path
 from typing import Optional
-from importlib import import_module, invalidate_caches
 
 _user_data_env_var = "SPECKLE_USERDATA_PATH"
 
@@ -55,9 +56,7 @@ def user_application_data_path() -> Path:
         if sys.platform.startswith("win"):
             app_data_path = os.getenv("APPDATA")
             if not app_data_path:
-                raise Exception(
-                    "Cannot get appdata path from environment."
-                )
+                raise Exception("Cannot get appdata path from environment.")
             return Path(app_data_path)
         else:
             # try getting the standard XDG_DATA_HOME value
@@ -68,9 +67,7 @@ def user_application_data_path() -> Path:
             else:
                 return _ensure_folder_exists(Path.home(), ".config")
     except Exception as ex:
-        raise Exception(
-            "Failed to initialize user application data path.", ex
-        )
+        raise Exception("Failed to initialize user application data path.", ex)
 
 
 def user_speckle_folder_path() -> Path:
@@ -90,19 +87,16 @@ def user_speckle_connector_installation_path(host_application: str) -> Path:
     )
 
 
-
-
-
-
 print("Starting module dependency installation")
 print(sys.executable)
 
 PYTHON_PATH = sys.executable
 
 
-
 def connector_installation_path(host_application: str) -> Path:
-    connector_installation_path = user_speckle_connector_installation_path(host_application)
+    connector_installation_path = user_speckle_connector_installation_path(
+        host_application
+    )
     connector_installation_path.mkdir(exist_ok=True, parents=True)
 
     # set user modules path at beginning of paths for earlier hit
@@ -113,7 +107,6 @@ def connector_installation_path(host_application: str) -> Path:
     return connector_installation_path
 
 
-
 def is_pip_available() -> bool:
     try:
         import_module("pip")  # noqa F401
@@ -132,25 +125,9 @@ def ensure_pip() -> None:
     if completed_process.returncode == 0:
         print("Successfully installed pip")
     else:
-        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")
+        raise Exception(
+            f"Failed to install pip, got {completed_process.returncode} return code"
+        )
 
 
 def get_requirements_path() -> Path:
@@ -169,12 +146,12 @@ def install_requirements(host_application: str) -> None:
 
     def debugger_is_active() -> bool:
         """Return if the debugger is currently active"""
-        return hasattr(sys, 'gettrace') and sys.gettrace() is not None
-    
+        return hasattr(sys, "gettrace") and sys.gettrace() is not None
+
     requirements_path = get_requirements_path()
 
     is_debug = debugger_is_active()
-    
+
     if not is_debug and not requirements_path.exists():
         print("Skipped installing dependencies")
         return
@@ -184,11 +161,15 @@ def install_requirements(host_application: str) -> None:
         [
             PYTHON_PATH,
             "-m",
-            "uv",
             "pip",
+            "-q",
+            "--disable-pip-version-check",
             "install",
-            "--system",
-            "--target",
+            "--prefer-binary",
+            "--ignore-installed",
+            "--no-compile",
+            "--no-deps",
+            "-t",
             str(path),
             "-r",
             str(requirements_path),
@@ -198,10 +179,10 @@ def install_requirements(host_application: str) -> None:
     )
 
     if completed_process.returncode != 0:
-        m = f"Failed to install dependencies through uv, got {completed_process.returncode} return code"
+        m = f"Failed to install dependencies through pip, got {completed_process.returncode} return code"
         print(m)
         raise Exception(m)
-    
+
     print("Successfully installed dependencies")
 
     if not is_debug:
@@ -211,9 +192,6 @@ 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)
 
@@ -223,7 +201,7 @@ def _import_dependencies() -> None:
     # the code above doesn't work for now, it fails on importing graphql-core
     # despite that, the connector seams to be working as expected
     # But it would be nice to make this solution work
-    # it would ensure that all dependencies are fully loaded  
+    # it would ensure that all dependencies are fully loaded
     # requirements = get_requirements_path().read_text()
     # reqs = [
     #     req.split(" ; ")[0].split("==")[0].split("[")[0].replace("-", "_")
@@ -234,6 +212,7 @@ def _import_dependencies() -> None:
     #     print(req)
     #     import_module("specklepy")
 
+
 def ensure_dependencies(host_application: str) -> None:
     try:
         install_dependencies(host_application)
@@ -241,6 +220,6 @@ def ensure_dependencies(host_application: str) -> None:
         _import_dependencies()
         print("Successfully found dependencies")
     except ImportError:
-        raise Exception(f"Cannot automatically ensure Speckle dependencies. Please try restarting the host application {host_application}!")
-
-
+        raise Exception(
+            f"Cannot automatically ensure Speckle dependencies. Please try restarting the host application {host_application}!"
+        )

bpy_speckle/operators/__init__.py

@@ -0,0 +1,37 @@
+from .commit import DeleteCommit
+from .misc import OpenSpeckleForum, OpenSpeckleGuide, OpenSpeckleTutorials
+from .streams import (
+    AddStreamFromURL,
+    CopyCommitId,
+    CopyModelId,
+    CopyStreamId,
+    CreateStream,
+    ReceiveStreamObjects,
+    SendStreamObjects,
+    ViewStreamDataApi,
+)
+from .users import LoadUsers, LoadUserStreams, ResetUsers
+
+operator_classes = [
+    LoadUsers,
+    ResetUsers,
+    ReceiveStreamObjects,
+    SendStreamObjects,
+    LoadUserStreams,
+    CopyStreamId,
+    CopyCommitId,
+    CopyModelId,
+]
+
+operator_classes.extend([DeleteCommit])
+
+operator_classes.extend(
+    [
+        ViewStreamDataApi,
+        AddStreamFromURL,
+        CreateStream,
+        OpenSpeckleGuide,
+        OpenSpeckleTutorials,
+        OpenSpeckleForum,
+    ]
+)

bpy_speckle/operators/commit.py

@@ -0,0 +1,73 @@
+"""
+Commit operators
+"""
+
+import bpy
+from bpy.props import BoolProperty
+from specklepy.logging import metrics
+
+from bpy_speckle.clients import speckle_clients
+from bpy_speckle.functions import _report
+from bpy_speckle.properties.scene import get_speckle
+
+
+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

@@ -0,0 +1,62 @@
+import webbrowser
+
+import bpy
+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/streams.py

@@ -0,0 +1,737 @@
+"""
+Stream operators
+"""
+
+import webbrowser
+from math import radians
+from typing import Callable, Dict, Optional, Tuple, Union, cast
+
+import bpy
+from bpy.props import BoolProperty, EnumProperty, StringProperty
+from bpy.types import Collection, Context, Object
+from deprecated import deprecated
+from specklepy.core.api import host_applications, operations
+from specklepy.core.api.client import SpeckleClient
+from specklepy.core.api.models import Commit, Stream
+from specklepy.core.api.wrapper import StreamWrapper
+from specklepy.logging import metrics
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects import Base
+from specklepy.objects.other import Collection as SCollection
+from specklepy.transports.server import ServerTransport
+
+from bpy_speckle.blender_commit_object_builder import BlenderCommitObjectBuilder
+from bpy_speckle.clients import speckle_clients
+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.convert.util import ConversionSkippedException, add_to_hierarchy
+from bpy_speckle.functions import _report, get_default_traversal_func, get_scale_length
+from bpy_speckle.operators.users import LoadUserStreams, add_user_stream
+from bpy_speckle.properties.scene import (
+    SpeckleSceneSettings,
+    SpeckleStreamObject,
+    SpeckleUserObject,
+    get_speckle,
+    selection_state,
+)
+
+ObjectCallback = Optional[Callable[[bpy.types.Context, Object, Base], Object]]
+ReceiveCompleteCallback = Optional[
+    Callable[[bpy.types.Context, Dict[str, Union[Object, Collection]]], None]
+]
+
+
+def get_project_workspace_id(client: SpeckleClient, project_id: str) -> Optional[str]:
+    workspace_id = None
+    server_version = client.project.server_version or client.server.version()
+
+    # Local yarn builds of server will report a server version if "dev"
+    # We'll assume that local builds are up-to-date with the latest features
+    if server_version[0] == "dev":
+        maj = 999
+        min = 999
+    else:
+        maj = server_version[0]
+        min = server_version[1]
+
+    if maj > 2 or (maj == 2 and min > 20):
+        workspace_id = client.project.get(project_id).workspaceId
+    return workspace_id
+
+
+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 is 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,
+                "workspace_id": get_project_workspace_id(client, stream.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",
+                "workspace_id": get_project_workspace_id(client, stream.id),
+            },
+        )
+
+        _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"},
+        )
+
+
+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"},
+        )

bpy_speckle/operators/users.py

@@ -0,0 +1,224 @@
+"""
+User account operators
+"""
+
+from typing import cast
+
+import bpy
+from bpy.types import Context
+from specklepy.core.api.client import SpeckleClient
+from specklepy.core.api.credentials import Account, get_local_accounts
+from specklepy.core.api.models import Stream
+from specklepy.logging import metrics
+
+from bpy_speckle.clients import speckle_clients
+from bpy_speckle.functions import _report
+from bpy_speckle.properties.scene import (
+    SpeckleSceneSettings,
+    SpeckleStreamObject,
+    SpeckleUserObject,
+    get_speckle,
+    restore_selection_state,
+)
+
+
+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("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

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

bpy_speckle/properties/addon.py

@@ -0,0 +1,18 @@
+"""
+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

@@ -0,0 +1,19 @@
+"""
+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

@@ -0,0 +1,19 @@
+"""
+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

@@ -0,0 +1,364 @@
+"""
+Scene properties
+"""
+
+from dataclasses import dataclass
+from typing import Iterable, Optional, Tuple, Union, cast
+
+import bpy
+from bpy.props import (
+    CollectionProperty,
+    EnumProperty,
+    FloatProperty,
+    IntProperty,
+    StringProperty,
+)
+from specklepy.core.api.models import Stream
+
+from bpy_speckle.clients import speckle_clients
+
+
+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 is not 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 is not 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 is not 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

@@ -0,0 +1,18 @@
+from .object import OBJECT_PT_speckle
+from .view3d import (
+    VIEW3D_PT_SpeckleActiveStream,
+    VIEW3D_PT_SpeckleHelp,
+    VIEW3D_PT_SpeckleStreams,
+    VIEW3D_PT_SpeckleUser,
+    VIEW3D_UL_SpeckleStreams,
+    VIEW3D_UL_SpeckleUsers,
+)
+
+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

@@ -0,0 +1,30 @@
+"""
+Object UI elements
+"""
+
+import bpy
+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 (Legacy)"
+
+    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

@@ -0,0 +1,267 @@
+"""
+Speckle UI elements for the 3d viewport
+"""
+
+from datetime import datetime
+
+import bpy
+
+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 (Legacy)"
+    bl_context = "objectmode"
+    bl_label = "User Account"
+
+    def draw(self, context):
+        speckle = get_speckle(context)
+
+        layout = self.layout
+        # Draw a box with the text "Warning: This is a legacy add-on. Download the new connector from https://app.speckle.systems/connectors"
+        box = layout.box()
+        box.label(text="Warning: This is a legacy add-on.", icon="ERROR")
+        box.label(text="Download the new connector from")
+        box.label(text="https://app.speckle.systems/connectors")
+        layout.separator()
+
+        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 (Legacy)"
+    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 (Legacy)"
+    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 (Legacy)"
+    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

@@ -0,0 +1,54 @@
+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
 
-uv pip compile pyproject.toml --output-file bpy_speckle/requirements.txt --all-extras
+poetry export --only main -o bpy_speckle/requirements.txt

patch_installer.py

@@ -0,0 +1,20 @@
+import sys
+from pathlib import Path
+
+
+def patch_installer(tag: str):
+    """Patches the installer with the correct connector version and specklepy version"""
+    tag = tag.replace("\n", "")
+    iss_file = "speckle-sharp-ci-tools/blender.iss"
+    iss_path = Path(iss_file)
+    lines = iss_path.read_text().split("\n")
+    lines.insert(12, f'#define AppVersion "{tag.split("-")[0]}"')
+    lines.insert(13, f'#define AppInfoVersion "{tag}"')
+
+    iss_path.write_text("\n".join(lines))
+    print(f"Patched installer with connector v{tag}")
+
+
+if __name__ == "__main__":
+    tag = sys.argv[1]
+    patch_installer(tag)

patch_version.py

@@ -1,47 +1,32 @@
 import re
 import sys
 
-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(FILE_PATH, "r") as file:
-        lines = file.readlines()
-
-        for (index, line) in enumerate(lines):
-            if '"version":' in line:
-                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):
+def patch_connector(tag):
     """Patches the connector version within the connector init file"""
-    FILE_PATH = "bpy_speckle/blender_manifest.toml"
-    version = simple_version.split(".")
+    bpy_file = "bpy_speckle/__init__.py"
+    tag = tag.split(".")
 
-    with open(FILE_PATH, "r") as file:
+    with open(bpy_file, "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}")
+        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}")
                 break
 
-        with open(FILE_PATH, "w") as file:
+        with open(bpy_file, "w") as file:
             file.writelines(lines)
 
+
 def main():
     tag = sys.argv[1]
     if not re.match(r"([0-9]+)\.([0-9]+)\.([0-9]+)", tag):
         raise ValueError(f"Invalid tag provided: {tag}")
 
     print(f"Patching version: {tag}")
-    simple_version = tag.split("-")[0]
-    patch_addon(simple_version)
-    patch_manifest(simple_version)
+    patch_connector(tag.split("-")[0])
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -1,16 +1,50 @@
-[project]
+[tool.poetry]
 name = "speckle-blender"
-version = "3.0.0"
-description = "Next-Gen Speckle connector for Blender!"
-requires-python = ">=3.11.9, <4.0.0"
+version = "2.0.0"
+description = "the Speckle 2.0 connector for Blender!"
+authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>", "Gergő Jedlicska <gergo@jedlicska.com>"]
 license = "Apache-2.0"
-dependencies = [
-    "specklepy==3.0.0a15",
-]
+package-mode = false
 
-[dependency-groups]
-dev = [
-    "fake-bpy-module-latest>=20240524,<20240525",
-    "ruff>=0.4.4,<0.5",
-]
+[tool.poetry.requires-plugins]
+poetry-plugin-export = ">=1.8"
 
+[tool.poetry.dependencies]
+python = ">=3.9.0, <4.0.0"
+specklepy = "^2.23.0"
+
+# [tool.poetry.group.local_specklepy.dependencies]
+# specklepy = {path = "../specklepy", develop = true}
+
+[tool.poetry.group.dev.dependencies]
+fake-bpy-module-latest = "^20241010"
+black = "24.10.0"
+isort = "^5.13.2"
+pylint = "^3.3.2"
+ruff = "^0.8.2"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+exclude = '''
+/(
+    \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+include = '\.pyi?$'
+line-length = 88
+target-version = ["py39", "py310", "py311", "py312", "py313"]
+
+[tool.isort]
+profile = "black"

uv.lock

@@ -1,788 +0,0 @@
-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.9.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "idna" },
-    { name = "sniffio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916 },
-]
-
-[[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.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 },
-]
-
-[[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 = "2025.4.26"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/9e/c05b3920a3b7d20d3d3310465f50348e5b3694f4f88c6daf736eef3024c4/certifi-2025.4.26.tar.gz", hash = "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6", size = 160705 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/7e/3db2bd1b1f9e95f7cddca6d6e75e2f2bd9f51b1246e546d88addca0106bd/certifi-2025.4.26-py3-none-any.whl", hash = "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3", size = 159618 },
-]
-
-[[package]]
-name = "charset-normalizer"
-version = "3.4.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794 },
-    { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846 },
-    { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350 },
-    { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657 },
-    { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260 },
-    { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164 },
-    { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571 },
-    { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952 },
-    { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959 },
-    { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030 },
-    { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015 },
-    { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106 },
-    { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402 },
-    { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936 },
-    { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790 },
-    { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924 },
-    { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626 },
-    { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567 },
-    { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957 },
-    { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408 },
-    { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399 },
-    { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815 },
-    { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537 },
-    { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565 },
-    { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357 },
-    { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776 },
-    { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622 },
-    { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435 },
-    { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653 },
-    { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231 },
-    { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243 },
-    { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442 },
-    { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147 },
-    { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057 },
-    { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454 },
-    { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174 },
-    { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166 },
-    { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064 },
-    { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641 },
-    { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626 },
-]
-
-[[package]]
-name = "deprecated"
-version = "1.2.18"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "wrapt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/98/97/06afe62762c9a8a86af0cfb7bfdab22a43ad17138b07af5b1a58442690a2/deprecated-1.2.18.tar.gz", hash = "sha256:422b6f6d859da6f2ef57857761bfb392480502a64c3028ca9bbe86085d72115d", size = 2928744 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6e/c6/ac0b6c1e2d138f1002bcf799d330bd6d85084fece321e662a14223794041/Deprecated-1.2.18-py2.py3-none-any.whl", hash = "sha256:bd5011788200372a32418f888e326a09ff80d0214bd961147cfed01b5c018eec", size = 9998 },
-]
-
-[[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.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "backoff" },
-    { name = "graphql-core" },
-    { name = "yarl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/49/ef/5298d9d628b6a54b3b810052cb5a935d324fe28d9bfdeb741733d5c2446b/gql-3.5.2.tar.gz", hash = "sha256:07e1325b820c8ba9478e95de27ce9f23250486e7e79113dbb7659a442dc13e74", size = 180502 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ff/71/b028b937992056e721bbf0371e13819fcca0dacde7b3c821f775ed903917/gql-3.5.2-py2.py3-none-any.whl", hash = "sha256:c830ffc38b3997b2a146317b27758305ab3d0da3bde607b49f34e32affb23ba2", size = 74346 },
-]
-
-[package.optional-dependencies]
-requests = [
-    { name = "requests" },
-    { name = "requests-toolbelt" },
-]
-websockets = [
-    { name = "websockets" },
-]
-
-[[package]]
-name = "graphql-core"
-version = "3.2.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/66/9e/aa527fb09a9d7399d5d7d2aa2da490e4580707652d3b4fc156996ae88a5b/graphql-core-3.2.4.tar.gz", hash = "sha256:acbe2e800980d0e39b4685dd058c2f4042660b89ebca38af83020fd872ff1264", size = 504611 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/33/cc72c4c658c6316f188a60bc4e5a91cd4ceaaa8c3e7e691ac9297e4e72c7/graphql_core-3.2.4-py3-none-any.whl", hash = "sha256:1604f2042edc5f3114f49cac9d77e25863be51b23a54a61a23245cf32f6476f0", size = 203179 },
-]
-
-[[package]]
-name = "h11"
-version = "0.16.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },
-]
-
-[[package]]
-name = "httpcore"
-version = "1.0.9"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "certifi" },
-    { name = "h11" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },
-]
-
-[[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.4.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/da/2c/e367dfb4c6538614a0c9453e510d75d66099edf1c4e69da1b5ce691a1931/multidict-6.4.3.tar.gz", hash = "sha256:3ada0b058c9f213c5f95ba301f922d402ac234f1111a7d8fd70f1b99f3c281ec", size = 89372 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/e0/53cf7f27eda48fffa53cfd4502329ed29e00efb9e4ce41362cbf8aa54310/multidict-6.4.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f6f19170197cc29baccd33ccc5b5d6a331058796485857cf34f7635aa25fb0cd", size = 65259 },
-    { url = "https://files.pythonhosted.org/packages/44/79/1dcd93ce7070cf01c2ee29f781c42b33c64fce20033808f1cc9ec8413d6e/multidict-6.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f2882bf27037eb687e49591690e5d491e677272964f9ec7bc2abbe09108bdfb8", size = 38451 },
-    { url = "https://files.pythonhosted.org/packages/f4/35/2292cf29ab5f0d0b3613fad1b75692148959d3834d806be1885ceb49a8ff/multidict-6.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fbf226ac85f7d6b6b9ba77db4ec0704fde88463dc17717aec78ec3c8546c70ad", size = 37706 },
-    { url = "https://files.pythonhosted.org/packages/f6/d1/6b157110b2b187b5a608b37714acb15ee89ec773e3800315b0107ea648cd/multidict-6.4.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e329114f82ad4b9dd291bef614ea8971ec119ecd0f54795109976de75c9a852", size = 226669 },
-    { url = "https://files.pythonhosted.org/packages/40/7f/61a476450651f177c5570e04bd55947f693077ba7804fe9717ee9ae8de04/multidict-6.4.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1f4e0334d7a555c63f5c8952c57ab6f1c7b4f8c7f3442df689fc9f03df315c08", size = 223182 },
-    { url = "https://files.pythonhosted.org/packages/51/7b/eaf7502ac4824cdd8edcf5723e2e99f390c879866aec7b0c420267b53749/multidict-6.4.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:740915eb776617b57142ce0bb13b7596933496e2f798d3d15a20614adf30d229", size = 235025 },
-    { url = "https://files.pythonhosted.org/packages/3b/f6/facdbbd73c96b67a93652774edd5778ab1167854fa08ea35ad004b1b70ad/multidict-6.4.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255dac25134d2b141c944b59a0d2f7211ca12a6d4779f7586a98b4b03ea80508", size = 231481 },
-    { url = "https://files.pythonhosted.org/packages/70/57/c008e861b3052405eebf921fd56a748322d8c44dcfcab164fffbccbdcdc4/multidict-6.4.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4e8535bd4d741039b5aad4285ecd9b902ef9e224711f0b6afda6e38d7ac02c7", size = 223492 },
-    { url = "https://files.pythonhosted.org/packages/30/4d/7d8440d3a12a6ae5d6b202d6e7f2ac6ab026e04e99aaf1b73f18e6bc34bc/multidict-6.4.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c433a33be000dd968f5750722eaa0991037be0be4a9d453eba121774985bc8", size = 217279 },
-    { url = "https://files.pythonhosted.org/packages/7f/e7/bca0df4dd057597b94138d2d8af04eb3c27396a425b1b0a52e082f9be621/multidict-6.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4eb33b0bdc50acd538f45041f5f19945a1f32b909b76d7b117c0c25d8063df56", size = 228733 },
-    { url = "https://files.pythonhosted.org/packages/88/f5/383827c3f1c38d7c92dbad00a8a041760228573b1c542fbf245c37bbca8a/multidict-6.4.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:75482f43465edefd8a5d72724887ccdcd0c83778ded8f0cb1e0594bf71736cc0", size = 218089 },
-    { url = "https://files.pythonhosted.org/packages/36/8a/a5174e8a7d8b94b4c8f9c1e2cf5d07451f41368ffe94d05fc957215b8e72/multidict-6.4.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ce5b3082e86aee80b3925ab4928198450d8e5b6466e11501fe03ad2191c6d777", size = 225257 },
-    { url = "https://files.pythonhosted.org/packages/8c/76/1d4b7218f0fd00b8e5c90b88df2e45f8af127f652f4e41add947fa54c1c4/multidict-6.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e413152e3212c4d39f82cf83c6f91be44bec9ddea950ce17af87fbf4e32ca6b2", size = 234728 },
-    { url = "https://files.pythonhosted.org/packages/64/44/18372a4f6273fc7ca25630d7bf9ae288cde64f29593a078bff450c7170b6/multidict-6.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:8aac2eeff69b71f229a405c0a4b61b54bade8e10163bc7b44fcd257949620618", size = 230087 },
-    { url = "https://files.pythonhosted.org/packages/0f/ae/28728c314a698d8a6d9491fcacc897077348ec28dd85884d09e64df8a855/multidict-6.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ab583ac203af1d09034be41458feeab7863c0635c650a16f15771e1386abf2d7", size = 223137 },
-    { url = "https://files.pythonhosted.org/packages/22/50/785bb2b3fe16051bc91c70a06a919f26312da45c34db97fc87441d61e343/multidict-6.4.3-cp311-cp311-win32.whl", hash = "sha256:1b2019317726f41e81154df636a897de1bfe9228c3724a433894e44cd2512378", size = 34959 },
-    { url = "https://files.pythonhosted.org/packages/2f/63/2a22e099ae2f4d92897618c00c73a09a08a2a9aa14b12736965bf8d59fd3/multidict-6.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:43173924fa93c7486402217fab99b60baf78d33806af299c56133a3755f69589", size = 38541 },
-    { url = "https://files.pythonhosted.org/packages/fc/bb/3abdaf8fe40e9226ce8a2ba5ecf332461f7beec478a455d6587159f1bf92/multidict-6.4.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1f1c2f58f08b36f8475f3ec6f5aeb95270921d418bf18f90dffd6be5c7b0e676", size = 64019 },
-    { url = "https://files.pythonhosted.org/packages/7e/b5/1b2e8de8217d2e89db156625aa0fe4a6faad98972bfe07a7b8c10ef5dd6b/multidict-6.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:26ae9ad364fc61b936fb7bf4c9d8bd53f3a5b4417142cd0be5c509d6f767e2f1", size = 37925 },
-    { url = "https://files.pythonhosted.org/packages/b4/e2/3ca91c112644a395c8eae017144c907d173ea910c913ff8b62549dcf0bbf/multidict-6.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:659318c6c8a85f6ecfc06b4e57529e5a78dfdd697260cc81f683492ad7e9435a", size = 37008 },
-    { url = "https://files.pythonhosted.org/packages/60/23/79bc78146c7ac8d1ac766b2770ca2e07c2816058b8a3d5da6caed8148637/multidict-6.4.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1eb72c741fd24d5a28242ce72bb61bc91f8451877131fa3fe930edb195f7054", size = 224374 },
-    { url = "https://files.pythonhosted.org/packages/86/35/77950ed9ebd09136003a85c1926ba42001ca5be14feb49710e4334ee199b/multidict-6.4.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3cd06d88cb7398252284ee75c8db8e680aa0d321451132d0dba12bc995f0adcc", size = 230869 },
-    { url = "https://files.pythonhosted.org/packages/49/97/2a33c6e7d90bc116c636c14b2abab93d6521c0c052d24bfcc231cbf7f0e7/multidict-6.4.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4543d8dc6470a82fde92b035a92529317191ce993533c3c0c68f56811164ed07", size = 231949 },
-    { url = "https://files.pythonhosted.org/packages/56/ce/e9b5d9fcf854f61d6686ada7ff64893a7a5523b2a07da6f1265eaaea5151/multidict-6.4.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:30a3ebdc068c27e9d6081fca0e2c33fdf132ecea703a72ea216b81a66860adde", size = 231032 },
-    { url = "https://files.pythonhosted.org/packages/f0/ac/7ced59dcdfeddd03e601edb05adff0c66d81ed4a5160c443e44f2379eef0/multidict-6.4.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b038f10e23f277153f86f95c777ba1958bcd5993194fda26a1d06fae98b2f00c", size = 223517 },
-    { url = "https://files.pythonhosted.org/packages/db/e6/325ed9055ae4e085315193a1b58bdb4d7fc38ffcc1f4975cfca97d015e17/multidict-6.4.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c605a2b2dc14282b580454b9b5d14ebe0668381a3a26d0ac39daa0ca115eb2ae", size = 216291 },
-    { url = "https://files.pythonhosted.org/packages/fa/84/eeee6d477dd9dcb7691c3bb9d08df56017f5dd15c730bcc9383dcf201cf4/multidict-6.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8bd2b875f4ca2bb527fe23e318ddd509b7df163407b0fb717df229041c6df5d3", size = 228982 },
-    { url = "https://files.pythonhosted.org/packages/82/94/4d1f3e74e7acf8b0c85db350e012dcc61701cd6668bc2440bb1ecb423c90/multidict-6.4.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c2e98c840c9c8e65c0e04b40c6c5066c8632678cd50c8721fdbcd2e09f21a507", size = 226823 },
-    { url = "https://files.pythonhosted.org/packages/09/f0/1e54b95bda7cd01080e5732f9abb7b76ab5cc795b66605877caeb2197476/multidict-6.4.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:66eb80dd0ab36dbd559635e62fba3083a48a252633164857a1d1684f14326427", size = 222714 },
-    { url = "https://files.pythonhosted.org/packages/e7/a2/f6cbca875195bd65a3e53b37ab46486f3cc125bdeab20eefe5042afa31fb/multidict-6.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c23831bdee0a2a3cf21be057b5e5326292f60472fb6c6f86392bbf0de70ba731", size = 233739 },
-    { url = "https://files.pythonhosted.org/packages/79/68/9891f4d2b8569554723ddd6154375295f789dc65809826c6fb96a06314fd/multidict-6.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1535cec6443bfd80d028052e9d17ba6ff8a5a3534c51d285ba56c18af97e9713", size = 230809 },
-    { url = "https://files.pythonhosted.org/packages/e6/72/a7be29ba1e87e4fc5ceb44dabc7940b8005fd2436a332a23547709315f70/multidict-6.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3b73e7227681f85d19dec46e5b881827cd354aabe46049e1a61d2f9aaa4e285a", size = 226934 },
-    { url = "https://files.pythonhosted.org/packages/12/c1/259386a9ad6840ff7afc686da96808b503d152ac4feb3a96c651dc4f5abf/multidict-6.4.3-cp312-cp312-win32.whl", hash = "sha256:8eac0c49df91b88bf91f818e0a24c1c46f3622978e2c27035bfdca98e0e18124", size = 35242 },
-    { url = "https://files.pythonhosted.org/packages/06/24/c8fdff4f924d37225dc0c56a28b1dca10728fc2233065fafeb27b4b125be/multidict-6.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:11990b5c757d956cd1db7cb140be50a63216af32cd6506329c2c59d732d802db", size = 38635 },
-    { url = "https://files.pythonhosted.org/packages/6c/4b/86fd786d03915c6f49998cf10cd5fe6b6ac9e9a071cb40885d2e080fb90d/multidict-6.4.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7a76534263d03ae0cfa721fea40fd2b5b9d17a6f85e98025931d41dc49504474", size = 63831 },
-    { url = "https://files.pythonhosted.org/packages/45/05/9b51fdf7aef2563340a93be0a663acba2c428c4daeaf3960d92d53a4a930/multidict-6.4.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:805031c2f599eee62ac579843555ed1ce389ae00c7e9f74c2a1b45e0564a88dd", size = 37888 },
-    { url = "https://files.pythonhosted.org/packages/0b/43/53fc25394386c911822419b522181227ca450cf57fea76e6188772a1bd91/multidict-6.4.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c56c179839d5dcf51d565132185409d1d5dd8e614ba501eb79023a6cab25576b", size = 36852 },
-    { url = "https://files.pythonhosted.org/packages/8a/68/7b99c751e822467c94a235b810a2fd4047d4ecb91caef6b5c60116991c4b/multidict-6.4.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c64f4ddb3886dd8ab71b68a7431ad4aa01a8fa5be5b11543b29674f29ca0ba3", size = 223644 },
-    { url = "https://files.pythonhosted.org/packages/80/1b/d458d791e4dd0f7e92596667784fbf99e5c8ba040affe1ca04f06b93ae92/multidict-6.4.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3002a856367c0b41cad6784f5b8d3ab008eda194ed7864aaa58f65312e2abcac", size = 230446 },
-    { url = "https://files.pythonhosted.org/packages/e2/46/9793378d988905491a7806d8987862dc5a0bae8a622dd896c4008c7b226b/multidict-6.4.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3d75e621e7d887d539d6e1d789f0c64271c250276c333480a9e1de089611f790", size = 231070 },
-    { url = "https://files.pythonhosted.org/packages/a7/b8/b127d3e1f8dd2a5bf286b47b24567ae6363017292dc6dec44656e6246498/multidict-6.4.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:995015cf4a3c0d72cbf453b10a999b92c5629eaf3a0c3e1efb4b5c1f602253bb", size = 229956 },
-    { url = "https://files.pythonhosted.org/packages/0c/93/f70a4c35b103fcfe1443059a2bb7f66e5c35f2aea7804105ff214f566009/multidict-6.4.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2b0fabae7939d09d7d16a711468c385272fa1b9b7fb0d37e51143585d8e72e0", size = 222599 },
-    { url = "https://files.pythonhosted.org/packages/63/8c/e28e0eb2fe34921d6aa32bfc4ac75b09570b4d6818cc95d25499fe08dc1d/multidict-6.4.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:61ed4d82f8a1e67eb9eb04f8587970d78fe7cddb4e4d6230b77eda23d27938f9", size = 216136 },
-    { url = "https://files.pythonhosted.org/packages/72/f5/fbc81f866585b05f89f99d108be5d6ad170e3b6c4d0723d1a2f6ba5fa918/multidict-6.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:062428944a8dc69df9fdc5d5fc6279421e5f9c75a9ee3f586f274ba7b05ab3c8", size = 228139 },
-    { url = "https://files.pythonhosted.org/packages/bb/ba/7d196bad6b85af2307d81f6979c36ed9665f49626f66d883d6c64d156f78/multidict-6.4.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b90e27b4674e6c405ad6c64e515a505c6d113b832df52fdacb6b1ffd1fa9a1d1", size = 226251 },
-    { url = "https://files.pythonhosted.org/packages/cc/e2/fae46a370dce79d08b672422a33df721ec8b80105e0ea8d87215ff6b090d/multidict-6.4.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7d50d4abf6729921e9613d98344b74241572b751c6b37feed75fb0c37bd5a817", size = 221868 },
-    { url = "https://files.pythonhosted.org/packages/26/20/bbc9a3dec19d5492f54a167f08546656e7aef75d181d3d82541463450e88/multidict-6.4.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:43fe10524fb0a0514be3954be53258e61d87341008ce4914f8e8b92bee6f875d", size = 233106 },
-    { url = "https://files.pythonhosted.org/packages/ee/8d/f30ae8f5ff7a2461177f4d8eb0d8f69f27fb6cfe276b54ec4fd5a282d918/multidict-6.4.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:236966ca6c472ea4e2d3f02f6673ebfd36ba3f23159c323f5a496869bc8e47c9", size = 230163 },
-    { url = "https://files.pythonhosted.org/packages/15/e9/2833f3c218d3c2179f3093f766940ded6b81a49d2e2f9c46ab240d23dfec/multidict-6.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:422a5ec315018e606473ba1f5431e064cf8b2a7468019233dcf8082fabad64c8", size = 225906 },
-    { url = "https://files.pythonhosted.org/packages/f1/31/6edab296ac369fd286b845fa5dd4c409e63bc4655ed8c9510fcb477e9ae9/multidict-6.4.3-cp313-cp313-win32.whl", hash = "sha256:f901a5aace8e8c25d78960dcc24c870c8d356660d3b49b93a78bf38eb682aac3", size = 35238 },
-    { url = "https://files.pythonhosted.org/packages/23/57/2c0167a1bffa30d9a1383c3dab99d8caae985defc8636934b5668830d2ef/multidict-6.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:1c152c49e42277bc9a2f7b78bd5fa10b13e88d1b0328221e7aef89d5c60a99a5", size = 38799 },
-    { url = "https://files.pythonhosted.org/packages/c9/13/2ead63b9ab0d2b3080819268acb297bd66e238070aa8d42af12b08cbee1c/multidict-6.4.3-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:be8751869e28b9c0d368d94f5afcb4234db66fe8496144547b4b6d6a0645cfc6", size = 68642 },
-    { url = "https://files.pythonhosted.org/packages/85/45/f1a751e1eede30c23951e2ae274ce8fad738e8a3d5714be73e0a41b27b16/multidict-6.4.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0d4b31f8a68dccbcd2c0ea04f0e014f1defc6b78f0eb8b35f2265e8716a6df0c", size = 40028 },
-    { url = "https://files.pythonhosted.org/packages/a7/29/fcc53e886a2cc5595cc4560df333cb9630257bda65003a7eb4e4e0d8f9c1/multidict-6.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:032efeab3049e37eef2ff91271884303becc9e54d740b492a93b7e7266e23756", size = 39424 },
-    { url = "https://files.pythonhosted.org/packages/f6/f0/056c81119d8b88703971f937b371795cab1407cd3c751482de5bfe1a04a9/multidict-6.4.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e78006af1a7c8a8007e4f56629d7252668344442f66982368ac06522445e375", size = 226178 },
-    { url = "https://files.pythonhosted.org/packages/a3/79/3b7e5fea0aa80583d3a69c9d98b7913dfd4fbc341fb10bb2fb48d35a9c21/multidict-6.4.3-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:daeac9dd30cda8703c417e4fddccd7c4dc0c73421a0b54a7da2713be125846be", size = 222617 },
-    { url = "https://files.pythonhosted.org/packages/06/db/3ed012b163e376fc461e1d6a67de69b408339bc31dc83d39ae9ec3bf9578/multidict-6.4.3-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f6f90700881438953eae443a9c6f8a509808bc3b185246992c4233ccee37fea", size = 227919 },
-    { url = "https://files.pythonhosted.org/packages/b1/db/0433c104bca380989bc04d3b841fc83e95ce0c89f680e9ea4251118b52b6/multidict-6.4.3-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f84627997008390dd15762128dcf73c3365f4ec0106739cde6c20a07ed198ec8", size = 226097 },
-    { url = "https://files.pythonhosted.org/packages/c2/95/910db2618175724dd254b7ae635b6cd8d2947a8b76b0376de7b96d814dab/multidict-6.4.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3307b48cd156153b117c0ea54890a3bdbf858a5b296ddd40dc3852e5f16e9b02", size = 220706 },
-    { url = "https://files.pythonhosted.org/packages/d1/af/aa176c6f5f1d901aac957d5258d5e22897fe13948d1e69063ae3d5d0ca01/multidict-6.4.3-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ead46b0fa1dcf5af503a46e9f1c2e80b5d95c6011526352fa5f42ea201526124", size = 211728 },
-    { url = "https://files.pythonhosted.org/packages/e7/42/d51cc5fc1527c3717d7f85137d6c79bb7a93cd214c26f1fc57523774dbb5/multidict-6.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1748cb2743bedc339d63eb1bca314061568793acd603a6e37b09a326334c9f44", size = 226276 },
-    { url = "https://files.pythonhosted.org/packages/28/6b/d836dea45e0b8432343ba4acf9a8ecaa245da4c0960fb7ab45088a5e568a/multidict-6.4.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:acc9fa606f76fc111b4569348cc23a771cb52c61516dcc6bcef46d612edb483b", size = 212069 },
-    { url = "https://files.pythonhosted.org/packages/55/34/0ee1a7adb3560e18ee9289c6e5f7db54edc312b13e5c8263e88ea373d12c/multidict-6.4.3-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:31469d5832b5885adeb70982e531ce86f8c992334edd2f2254a10fa3182ac504", size = 217858 },
-    { url = "https://files.pythonhosted.org/packages/04/08/586d652c2f5acefe0cf4e658eedb4d71d4ba6dfd4f189bd81b400fc1bc6b/multidict-6.4.3-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ba46b51b6e51b4ef7bfb84b82f5db0dc5e300fb222a8a13b8cd4111898a869cf", size = 226988 },
-    { url = "https://files.pythonhosted.org/packages/82/e3/cc59c7e2bc49d7f906fb4ffb6d9c3a3cf21b9f2dd9c96d05bef89c2b1fd1/multidict-6.4.3-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:389cfefb599edf3fcfd5f64c0410da686f90f5f5e2c4d84e14f6797a5a337af4", size = 220435 },
-    { url = "https://files.pythonhosted.org/packages/e0/32/5c3a556118aca9981d883f38c4b1bfae646f3627157f70f4068e5a648955/multidict-6.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:64bc2bbc5fba7b9db5c2c8d750824f41c6994e3882e6d73c903c2afa78d091e4", size = 221494 },
-    { url = "https://files.pythonhosted.org/packages/b9/3b/1599631f59024b75c4d6e3069f4502409970a336647502aaf6b62fb7ac98/multidict-6.4.3-cp313-cp313t-win32.whl", hash = "sha256:0ecdc12ea44bab2807d6b4a7e5eef25109ab1c82a8240d86d3c1fc9f3b72efd5", size = 41775 },
-    { url = "https://files.pythonhosted.org/packages/e8/4e/09301668d675d02ca8e8e1a3e6be046619e30403f5ada2ed5b080ae28d02/multidict-6.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:7146a8742ea71b5d7d955bffcef58a9e6e04efba704b52a460134fefd10a8208", size = 45946 },
-    { url = "https://files.pythonhosted.org/packages/96/10/7d526c8974f017f1e7ca584c71ee62a638e9334d8d33f27d7cdfc9ae79e4/multidict-6.4.3-py3-none-any.whl", hash = "sha256:59fe01ee8e2a1e8ceb3f6dbb216b09c8d9f4ef1c22c4fc825d045a147fa2ebc9", size = 10400 },
-]
-
-[[package]]
-name = "propcache"
-version = "0.3.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/07/c8/fdc6686a986feae3541ea23dcaa661bd93972d3940460646c6bb96e21c40/propcache-0.3.1.tar.gz", hash = "sha256:40d980c33765359098837527e18eddefc9a24cea5b45e078a7f3bb5b032c6ecf", size = 43651 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/0f/5a5319ee83bd651f75311fcb0c492c21322a7fc8f788e4eef23f44243427/propcache-0.3.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7f30241577d2fef2602113b70ef7231bf4c69a97e04693bde08ddab913ba0ce5", size = 80243 },
-    { url = "https://files.pythonhosted.org/packages/ce/84/3db5537e0879942783e2256616ff15d870a11d7ac26541336fe1b673c818/propcache-0.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:43593c6772aa12abc3af7784bff4a41ffa921608dd38b77cf1dfd7f5c4e71371", size = 46503 },
-    { url = "https://files.pythonhosted.org/packages/e2/c8/b649ed972433c3f0d827d7f0cf9ea47162f4ef8f4fe98c5f3641a0bc63ff/propcache-0.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a75801768bbe65499495660b777e018cbe90c7980f07f8aa57d6be79ea6f71da", size = 45934 },
-    { url = "https://files.pythonhosted.org/packages/59/f9/4c0a5cf6974c2c43b1a6810c40d889769cc8f84cea676cbe1e62766a45f8/propcache-0.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6f1324db48f001c2ca26a25fa25af60711e09b9aaf4b28488602776f4f9a744", size = 233633 },
-    { url = "https://files.pythonhosted.org/packages/e7/64/66f2f4d1b4f0007c6e9078bd95b609b633d3957fe6dd23eac33ebde4b584/propcache-0.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cdb0f3e1eb6dfc9965d19734d8f9c481b294b5274337a8cb5cb01b462dcb7e0", size = 241124 },
-    { url = "https://files.pythonhosted.org/packages/aa/bf/7b8c9fd097d511638fa9b6af3d986adbdf567598a567b46338c925144c1b/propcache-0.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1eb34d90aac9bfbced9a58b266f8946cb5935869ff01b164573a7634d39fbcb5", size = 240283 },
-    { url = "https://files.pythonhosted.org/packages/fa/c9/e85aeeeaae83358e2a1ef32d6ff50a483a5d5248bc38510d030a6f4e2816/propcache-0.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f35c7070eeec2cdaac6fd3fe245226ed2a6292d3ee8c938e5bb645b434c5f256", size = 232498 },
-    { url = "https://files.pythonhosted.org/packages/8e/66/acb88e1f30ef5536d785c283af2e62931cb934a56a3ecf39105887aa8905/propcache-0.3.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b23c11c2c9e6d4e7300c92e022046ad09b91fd00e36e83c44483df4afa990073", size = 221486 },
-    { url = "https://files.pythonhosted.org/packages/f5/f9/233ddb05ffdcaee4448508ee1d70aa7deff21bb41469ccdfcc339f871427/propcache-0.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3e19ea4ea0bf46179f8a3652ac1426e6dcbaf577ce4b4f65be581e237340420d", size = 222675 },
-    { url = "https://files.pythonhosted.org/packages/98/b8/eb977e28138f9e22a5a789daf608d36e05ed93093ef12a12441030da800a/propcache-0.3.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:bd39c92e4c8f6cbf5f08257d6360123af72af9f4da75a690bef50da77362d25f", size = 215727 },
-    { url = "https://files.pythonhosted.org/packages/89/2d/5f52d9c579f67b8ee1edd9ec073c91b23cc5b7ff7951a1e449e04ed8fdf3/propcache-0.3.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b0313e8b923b3814d1c4a524c93dfecea5f39fa95601f6a9b1ac96cd66f89ea0", size = 217878 },
-    { url = "https://files.pythonhosted.org/packages/7a/fd/5283e5ed8a82b00c7a989b99bb6ea173db1ad750bf0bf8dff08d3f4a4e28/propcache-0.3.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e861ad82892408487be144906a368ddbe2dc6297074ade2d892341b35c59844a", size = 230558 },
-    { url = "https://files.pythonhosted.org/packages/90/38/ab17d75938ef7ac87332c588857422ae126b1c76253f0f5b1242032923ca/propcache-0.3.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:61014615c1274df8da5991a1e5da85a3ccb00c2d4701ac6f3383afd3ca47ab0a", size = 233754 },
-    { url = "https://files.pythonhosted.org/packages/06/5d/3b921b9c60659ae464137508d3b4c2b3f52f592ceb1964aa2533b32fcf0b/propcache-0.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:71ebe3fe42656a2328ab08933d420df5f3ab121772eef78f2dc63624157f0ed9", size = 226088 },
-    { url = "https://files.pythonhosted.org/packages/54/6e/30a11f4417d9266b5a464ac5a8c5164ddc9dd153dfa77bf57918165eb4ae/propcache-0.3.1-cp311-cp311-win32.whl", hash = "sha256:58aa11f4ca8b60113d4b8e32d37e7e78bd8af4d1a5b5cb4979ed856a45e62005", size = 40859 },
-    { url = "https://files.pythonhosted.org/packages/1d/3a/8a68dd867da9ca2ee9dfd361093e9cb08cb0f37e5ddb2276f1b5177d7731/propcache-0.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:9532ea0b26a401264b1365146c440a6d78269ed41f83f23818d4b79497aeabe7", size = 45153 },
-    { url = "https://files.pythonhosted.org/packages/41/aa/ca78d9be314d1e15ff517b992bebbed3bdfef5b8919e85bf4940e57b6137/propcache-0.3.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f78eb8422acc93d7b69964012ad7048764bb45a54ba7a39bb9e146c72ea29723", size = 80430 },
-    { url = "https://files.pythonhosted.org/packages/1a/d8/f0c17c44d1cda0ad1979af2e593ea290defdde9eaeb89b08abbe02a5e8e1/propcache-0.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:89498dd49c2f9a026ee057965cdf8192e5ae070ce7d7a7bd4b66a8e257d0c976", size = 46637 },
-    { url = "https://files.pythonhosted.org/packages/ae/bd/c1e37265910752e6e5e8a4c1605d0129e5b7933c3dc3cf1b9b48ed83b364/propcache-0.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:09400e98545c998d57d10035ff623266927cb784d13dd2b31fd33b8a5316b85b", size = 46123 },
-    { url = "https://files.pythonhosted.org/packages/d4/b0/911eda0865f90c0c7e9f0415d40a5bf681204da5fd7ca089361a64c16b28/propcache-0.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa8efd8c5adc5a2c9d3b952815ff8f7710cefdcaf5f2c36d26aff51aeca2f12f", size = 243031 },
-    { url = "https://files.pythonhosted.org/packages/0a/06/0da53397c76a74271621807265b6eb61fb011451b1ddebf43213df763669/propcache-0.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c2fe5c910f6007e716a06d269608d307b4f36e7babee5f36533722660e8c4a70", size = 249100 },
-    { url = "https://files.pythonhosted.org/packages/f1/eb/13090e05bf6b963fc1653cdc922133ced467cb4b8dab53158db5a37aa21e/propcache-0.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a0ab8cf8cdd2194f8ff979a43ab43049b1df0b37aa64ab7eca04ac14429baeb7", size = 250170 },
-    { url = "https://files.pythonhosted.org/packages/3b/4c/f72c9e1022b3b043ec7dc475a0f405d4c3e10b9b1d378a7330fecf0652da/propcache-0.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:563f9d8c03ad645597b8d010ef4e9eab359faeb11a0a2ac9f7b4bc8c28ebef25", size = 245000 },
-    { url = "https://files.pythonhosted.org/packages/e8/fd/970ca0e22acc829f1adf5de3724085e778c1ad8a75bec010049502cb3a86/propcache-0.3.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb6e0faf8cb6b4beea5d6ed7b5a578254c6d7df54c36ccd3d8b3eb00d6770277", size = 230262 },
-    { url = "https://files.pythonhosted.org/packages/c4/42/817289120c6b9194a44f6c3e6b2c3277c5b70bbad39e7df648f177cc3634/propcache-0.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1c5c7ab7f2bb3f573d1cb921993006ba2d39e8621019dffb1c5bc94cdbae81e8", size = 236772 },
-    { url = "https://files.pythonhosted.org/packages/7c/9c/3b3942b302badd589ad6b672da3ca7b660a6c2f505cafd058133ddc73918/propcache-0.3.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:050b571b2e96ec942898f8eb46ea4bfbb19bd5502424747e83badc2d4a99a44e", size = 231133 },
-    { url = "https://files.pythonhosted.org/packages/98/a1/75f6355f9ad039108ff000dfc2e19962c8dea0430da9a1428e7975cf24b2/propcache-0.3.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e1c4d24b804b3a87e9350f79e2371a705a188d292fd310e663483af6ee6718ee", size = 230741 },
-    { url = "https://files.pythonhosted.org/packages/67/0c/3e82563af77d1f8731132166da69fdfd95e71210e31f18edce08a1eb11ea/propcache-0.3.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e4fe2a6d5ce975c117a6bb1e8ccda772d1e7029c1cca1acd209f91d30fa72815", size = 244047 },
-    { url = "https://files.pythonhosted.org/packages/f7/50/9fb7cca01532a08c4d5186d7bb2da6c4c587825c0ae134b89b47c7d62628/propcache-0.3.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:feccd282de1f6322f56f6845bf1207a537227812f0a9bf5571df52bb418d79d5", size = 246467 },
-    { url = "https://files.pythonhosted.org/packages/a9/02/ccbcf3e1c604c16cc525309161d57412c23cf2351523aedbb280eb7c9094/propcache-0.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ec314cde7314d2dd0510c6787326bbffcbdc317ecee6b7401ce218b3099075a7", size = 241022 },
-    { url = "https://files.pythonhosted.org/packages/db/19/e777227545e09ca1e77a6e21274ae9ec45de0f589f0ce3eca2a41f366220/propcache-0.3.1-cp312-cp312-win32.whl", hash = "sha256:7d2d5a0028d920738372630870e7d9644ce437142197f8c827194fca404bf03b", size = 40647 },
-    { url = "https://files.pythonhosted.org/packages/24/bb/3b1b01da5dd04c77a204c84e538ff11f624e31431cfde7201d9110b092b1/propcache-0.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:88c423efef9d7a59dae0614eaed718449c09a5ac79a5f224a8b9664d603f04a3", size = 44784 },
-    { url = "https://files.pythonhosted.org/packages/58/60/f645cc8b570f99be3cf46714170c2de4b4c9d6b827b912811eff1eb8a412/propcache-0.3.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f1528ec4374617a7a753f90f20e2f551121bb558fcb35926f99e3c42367164b8", size = 77865 },
-    { url = "https://files.pythonhosted.org/packages/6f/d4/c1adbf3901537582e65cf90fd9c26fde1298fde5a2c593f987112c0d0798/propcache-0.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc1915ec523b3b494933b5424980831b636fe483d7d543f7afb7b3bf00f0c10f", size = 45452 },
-    { url = "https://files.pythonhosted.org/packages/d1/b5/fe752b2e63f49f727c6c1c224175d21b7d1727ce1d4873ef1c24c9216830/propcache-0.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a110205022d077da24e60b3df8bcee73971be9575dec5573dd17ae5d81751111", size = 44800 },
-    { url = "https://files.pythonhosted.org/packages/62/37/fc357e345bc1971e21f76597028b059c3d795c5ca7690d7a8d9a03c9708a/propcache-0.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d249609e547c04d190e820d0d4c8ca03ed4582bcf8e4e160a6969ddfb57b62e5", size = 225804 },
-    { url = "https://files.pythonhosted.org/packages/0d/f1/16e12c33e3dbe7f8b737809bad05719cff1dccb8df4dafbcff5575002c0e/propcache-0.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ced33d827625d0a589e831126ccb4f5c29dfdf6766cac441d23995a65825dcb", size = 230650 },
-    { url = "https://files.pythonhosted.org/packages/3e/a2/018b9f2ed876bf5091e60153f727e8f9073d97573f790ff7cdf6bc1d1fb8/propcache-0.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4114c4ada8f3181af20808bedb250da6bae56660e4b8dfd9cd95d4549c0962f7", size = 234235 },
-    { url = "https://files.pythonhosted.org/packages/45/5f/3faee66fc930dfb5da509e34c6ac7128870631c0e3582987fad161fcb4b1/propcache-0.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:975af16f406ce48f1333ec5e912fe11064605d5c5b3f6746969077cc3adeb120", size = 228249 },
-    { url = "https://files.pythonhosted.org/packages/62/1e/a0d5ebda5da7ff34d2f5259a3e171a94be83c41eb1e7cd21a2105a84a02e/propcache-0.3.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a34aa3a1abc50740be6ac0ab9d594e274f59960d3ad253cd318af76b996dd654", size = 214964 },
-    { url = "https://files.pythonhosted.org/packages/db/a0/d72da3f61ceab126e9be1f3bc7844b4e98c6e61c985097474668e7e52152/propcache-0.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9cec3239c85ed15bfaded997773fdad9fb5662b0a7cbc854a43f291eb183179e", size = 222501 },
-    { url = "https://files.pythonhosted.org/packages/18/6d/a008e07ad7b905011253adbbd97e5b5375c33f0b961355ca0a30377504ac/propcache-0.3.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:05543250deac8e61084234d5fc54f8ebd254e8f2b39a16b1dce48904f45b744b", size = 217917 },
-    { url = "https://files.pythonhosted.org/packages/98/37/02c9343ffe59e590e0e56dc5c97d0da2b8b19fa747ebacf158310f97a79a/propcache-0.3.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5cb5918253912e088edbf023788de539219718d3b10aef334476b62d2b53de53", size = 217089 },
-    { url = "https://files.pythonhosted.org/packages/53/1b/d3406629a2c8a5666d4674c50f757a77be119b113eedd47b0375afdf1b42/propcache-0.3.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f3bbecd2f34d0e6d3c543fdb3b15d6b60dd69970c2b4c822379e5ec8f6f621d5", size = 228102 },
-    { url = "https://files.pythonhosted.org/packages/cd/a7/3664756cf50ce739e5f3abd48febc0be1a713b1f389a502ca819791a6b69/propcache-0.3.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aca63103895c7d960a5b9b044a83f544b233c95e0dcff114389d64d762017af7", size = 230122 },
-    { url = "https://files.pythonhosted.org/packages/35/36/0bbabaacdcc26dac4f8139625e930f4311864251276033a52fd52ff2a274/propcache-0.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a0a9898fdb99bf11786265468571e628ba60af80dc3f6eb89a3545540c6b0ef", size = 226818 },
-    { url = "https://files.pythonhosted.org/packages/cc/27/4e0ef21084b53bd35d4dae1634b6d0bad35e9c58ed4f032511acca9d4d26/propcache-0.3.1-cp313-cp313-win32.whl", hash = "sha256:3a02a28095b5e63128bcae98eb59025924f121f048a62393db682f049bf4ac24", size = 40112 },
-    { url = "https://files.pythonhosted.org/packages/a6/2c/a54614d61895ba6dd7ac8f107e2b2a0347259ab29cbf2ecc7b94fa38c4dc/propcache-0.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:813fbb8b6aea2fc9659815e585e548fe706d6f663fa73dff59a1677d4595a037", size = 44034 },
-    { url = "https://files.pythonhosted.org/packages/5a/a8/0a4fd2f664fc6acc66438370905124ce62e84e2e860f2557015ee4a61c7e/propcache-0.3.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a444192f20f5ce8a5e52761a031b90f5ea6288b1eef42ad4c7e64fef33540b8f", size = 82613 },
-    { url = "https://files.pythonhosted.org/packages/4d/e5/5ef30eb2cd81576256d7b6caaa0ce33cd1d2c2c92c8903cccb1af1a4ff2f/propcache-0.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0fbe94666e62ebe36cd652f5fc012abfbc2342de99b523f8267a678e4dfdee3c", size = 47763 },
-    { url = "https://files.pythonhosted.org/packages/87/9a/87091ceb048efeba4d28e903c0b15bcc84b7c0bf27dc0261e62335d9b7b8/propcache-0.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f011f104db880f4e2166bcdcf7f58250f7a465bc6b068dc84c824a3d4a5c94dc", size = 47175 },
-    { url = "https://files.pythonhosted.org/packages/3e/2f/854e653c96ad1161f96194c6678a41bbb38c7947d17768e8811a77635a08/propcache-0.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e584b6d388aeb0001d6d5c2bd86b26304adde6d9bb9bfa9c4889805021b96de", size = 292265 },
-    { url = "https://files.pythonhosted.org/packages/40/8d/090955e13ed06bc3496ba4a9fb26c62e209ac41973cb0d6222de20c6868f/propcache-0.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8a17583515a04358b034e241f952f1715243482fc2c2945fd99a1b03a0bd77d6", size = 294412 },
-    { url = "https://files.pythonhosted.org/packages/39/e6/d51601342e53cc7582449e6a3c14a0479fab2f0750c1f4d22302e34219c6/propcache-0.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5aed8d8308215089c0734a2af4f2e95eeb360660184ad3912686c181e500b2e7", size = 294290 },
-    { url = "https://files.pythonhosted.org/packages/3b/4d/be5f1a90abc1881884aa5878989a1acdafd379a91d9c7e5e12cef37ec0d7/propcache-0.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d8e309ff9a0503ef70dc9a0ebd3e69cf7b3894c9ae2ae81fc10943c37762458", size = 282926 },
-    { url = "https://files.pythonhosted.org/packages/57/2b/8f61b998c7ea93a2b7eca79e53f3e903db1787fca9373af9e2cf8dc22f9d/propcache-0.3.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b655032b202028a582d27aeedc2e813299f82cb232f969f87a4fde491a233f11", size = 267808 },
-    { url = "https://files.pythonhosted.org/packages/11/1c/311326c3dfce59c58a6098388ba984b0e5fb0381ef2279ec458ef99bd547/propcache-0.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f64d91b751df77931336b5ff7bafbe8845c5770b06630e27acd5dbb71e1931c", size = 290916 },
-    { url = "https://files.pythonhosted.org/packages/4b/74/91939924b0385e54dc48eb2e4edd1e4903ffd053cf1916ebc5347ac227f7/propcache-0.3.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:19a06db789a4bd896ee91ebc50d059e23b3639c25d58eb35be3ca1cbe967c3bf", size = 262661 },
-    { url = "https://files.pythonhosted.org/packages/c2/d7/e6079af45136ad325c5337f5dd9ef97ab5dc349e0ff362fe5c5db95e2454/propcache-0.3.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:bef100c88d8692864651b5f98e871fb090bd65c8a41a1cb0ff2322db39c96c27", size = 264384 },
-    { url = "https://files.pythonhosted.org/packages/b7/d5/ba91702207ac61ae6f1c2da81c5d0d6bf6ce89e08a2b4d44e411c0bbe867/propcache-0.3.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:87380fb1f3089d2a0b8b00f006ed12bd41bd858fabfa7330c954c70f50ed8757", size = 291420 },
-    { url = "https://files.pythonhosted.org/packages/58/70/2117780ed7edcd7ba6b8134cb7802aada90b894a9810ec56b7bb6018bee7/propcache-0.3.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e474fc718e73ba5ec5180358aa07f6aded0ff5f2abe700e3115c37d75c947e18", size = 290880 },
-    { url = "https://files.pythonhosted.org/packages/4a/1f/ecd9ce27710021ae623631c0146719280a929d895a095f6d85efb6a0be2e/propcache-0.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:17d1c688a443355234f3c031349da69444be052613483f3e4158eef751abcd8a", size = 287407 },
-    { url = "https://files.pythonhosted.org/packages/3e/66/2e90547d6b60180fb29e23dc87bd8c116517d4255240ec6d3f7dc23d1926/propcache-0.3.1-cp313-cp313t-win32.whl", hash = "sha256:359e81a949a7619802eb601d66d37072b79b79c2505e6d3fd8b945538411400d", size = 42573 },
-    { url = "https://files.pythonhosted.org/packages/cb/8f/50ad8599399d1861b4d2b6b45271f0ef6af1b09b0a2386a46dbaf19c9535/propcache-0.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e7fb9a84c9abbf2b2683fa3e7b0d7da4d8ecf139a1c635732a8bda29c5214b0e", size = 46757 },
-    { url = "https://files.pythonhosted.org/packages/b8/d3/c3cb8f1d6ae3b37f83e1de806713a9b3642c5895f0215a62e1a4bd6e5e34/propcache-0.3.1-py3-none-any.whl", hash = "sha256:9a8ecf38de50a7f518c21568c80f985e776397b902f1ce0b01f799aba1608b40", size = 12376 },
-]
-
-[[package]]
-name = "pydantic"
-version = "2.11.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "annotated-types" },
-    { name = "pydantic-core" },
-    { name = "typing-extensions" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/77/ab/5250d56ad03884ab5efd07f734203943c8a8ab40d551e208af81d0257bf2/pydantic-2.11.4.tar.gz", hash = "sha256:32738d19d63a226a52eed76645a98ee07c1f410ee41d93b4afbfa85ed8111c2d", size = 786540 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e7/12/46b65f3534d099349e38ef6ec98b1a5a81f42536d17e0ba382c28c67ba67/pydantic-2.11.4-py3-none-any.whl", hash = "sha256:d9615eaa9ac5a063471da949c8fc16376a84afb5024688b3ff885693506764eb", size = 443900 },
-]
-
-[[package]]
-name = "pydantic-core"
-version = "2.33.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584 },
-    { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071 },
-    { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823 },
-    { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792 },
-    { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338 },
-    { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998 },
-    { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200 },
-    { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890 },
-    { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359 },
-    { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883 },
-    { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074 },
-    { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538 },
-    { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909 },
-    { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786 },
-    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000 },
-    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996 },
-    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957 },
-    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199 },
-    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296 },
-    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109 },
-    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028 },
-    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044 },
-    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881 },
-    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034 },
-    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187 },
-    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628 },
-    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866 },
-    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894 },
-    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688 },
-    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808 },
-    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580 },
-    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859 },
-    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810 },
-    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498 },
-    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611 },
-    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924 },
-    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196 },
-    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389 },
-    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223 },
-    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473 },
-    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269 },
-    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921 },
-    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162 },
-    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560 },
-    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777 },
-    { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200 },
-    { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123 },
-    { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852 },
-    { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484 },
-    { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896 },
-    { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475 },
-    { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013 },
-    { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715 },
-    { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757 },
-]
-
-[[package]]
-name = "pydantic-settings"
-version = "2.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "typing-inspection" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/67/1d/42628a2c33e93f8e9acbde0d5d735fa0850f3e6a2f8cb1eb6c40b9a732ac/pydantic_settings-2.9.1.tar.gz", hash = "sha256:c509bf79d27563add44e8446233359004ed85066cd096d8b510f715e6ef5d268", size = 163234 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b6/5f/d6d641b490fd3ec2c4c13b4244d68deea3a1b970a97be64f34fb5504ff72/pydantic_settings-2.9.1-py3-none-any.whl", hash = "sha256:59b4f431b1defb26fe620c71a7d3968a710d719f5f4cdbbdb7926edeb770f6ef", size = 44356 },
-]
-
-[[package]]
-name = "python-dotenv"
-version = "1.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/88/2c/7bb1416c5620485aa793f2de31d3df393d3686aa8a8506d11e10e13c5baf/python_dotenv-1.1.0.tar.gz", hash = "sha256:41f90bc6f5f177fb41f53e87666db362025010eb28f60a01c9143bfa33a2b2d5", size = 39920 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/18/98a99ad95133c6a6e2005fe89faedf294a748bd5dc803008059409ac9b1e/python_dotenv-1.1.0-py3-none-any.whl", hash = "sha256:d7c01d9e2293916c18baf562d95698754b0dbbb5e74d457c45d4f6561fb9d55d", size = 20256 },
-]
-
-[[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.0a15" }]
-
-[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.0a15"
-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/8b/00/ef793063b92c4e998bae227cf3a94c640181ac63f385a5be2b15ff806f0d/specklepy-3.0.0a15.tar.gz", hash = "sha256:60bfce016d58e31f7f4b5b8bb61cc8528dc0404b1246fac96bc961ee46cb0816", size = 199633 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/f5/a8acbfa11b9d8a02baf291fd36ad67d495f90c862b510133f88e7cc59861/specklepy-3.0.0a15-py3-none-any.whl", hash = "sha256:129816063ef692e8566e95e8201b3dabfb8835a67aa91d05bd6d2b10ed8449fa", size = 100948 },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.13.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806 },
-]
-
-[[package]]
-name = "typing-inspection"
-version = "0.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/82/5c/e6082df02e215b846b4b8c0b887a64d7d08ffaba30605502639d44c06b82/typing_inspection-0.4.0.tar.gz", hash = "sha256:9765c87de36671694a67904bf2c96e395be9c6439bb6c87b5142569dcdd65122", size = 76222 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/08/aa4fdfb71f7de5176385bd9e90852eaf6b5d622735020ad600f2bab54385/typing_inspection-0.4.0-py3-none-any.whl", hash = "sha256:50e72559fcd2a6367a19f7a7e610e6afcb9fac940c650290eed893d61386832f", size = 14125 },
-]
-
-[[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.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680 },
-]
-
-[[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.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cd/f7/a2aab2cbc7a665efab072344a8949a71081eed1d2f451f7f7d2b966594a2/wrapt-1.17.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ff04ef6eec3eee8a5efef2401495967a916feaa353643defcc03fc74fe213b58", size = 53308 },
-    { url = "https://files.pythonhosted.org/packages/50/ff/149aba8365fdacef52b31a258c4dc1c57c79759c335eff0b3316a2664a64/wrapt-1.17.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4db983e7bca53819efdbd64590ee96c9213894272c776966ca6306b73e4affda", size = 38488 },
-    { url = "https://files.pythonhosted.org/packages/65/46/5a917ce85b5c3b490d35c02bf71aedaa9f2f63f2d15d9949cc4ba56e8ba9/wrapt-1.17.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9abc77a4ce4c6f2a3168ff34b1da9b0f311a8f1cfd694ec96b0603dff1c79438", size = 38776 },
-    { url = "https://files.pythonhosted.org/packages/ca/74/336c918d2915a4943501c77566db41d1bd6e9f4dbc317f356b9a244dfe83/wrapt-1.17.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b929ac182f5ace000d459c59c2c9c33047e20e935f8e39371fa6e3b85d56f4a", size = 83776 },
-    { url = "https://files.pythonhosted.org/packages/09/99/c0c844a5ccde0fe5761d4305485297f91d67cf2a1a824c5f282e661ec7ff/wrapt-1.17.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f09b286faeff3c750a879d336fb6d8713206fc97af3adc14def0cdd349df6000", size = 75420 },
-    { url = "https://files.pythonhosted.org/packages/b4/b0/9fc566b0fe08b282c850063591a756057c3247b2362b9286429ec5bf1721/wrapt-1.17.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7ed2d9d039bd41e889f6fb9364554052ca21ce823580f6a07c4ec245c1f5d6", size = 83199 },
-    { url = "https://files.pythonhosted.org/packages/9d/4b/71996e62d543b0a0bd95dda485219856def3347e3e9380cc0d6cf10cfb2f/wrapt-1.17.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:129a150f5c445165ff941fc02ee27df65940fcb8a22a61828b1853c98763a64b", size = 82307 },
-    { url = "https://files.pythonhosted.org/packages/39/35/0282c0d8789c0dc9bcc738911776c762a701f95cfe113fb8f0b40e45c2b9/wrapt-1.17.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1fb5699e4464afe5c7e65fa51d4f99e0b2eadcc176e4aa33600a3df7801d6662", size = 75025 },
-    { url = "https://files.pythonhosted.org/packages/4f/6d/90c9fd2c3c6fee181feecb620d95105370198b6b98a0770cba090441a828/wrapt-1.17.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9a2bce789a5ea90e51a02dfcc39e31b7f1e662bc3317979aa7e5538e3a034f72", size = 81879 },
-    { url = "https://files.pythonhosted.org/packages/8f/fa/9fb6e594f2ce03ef03eddbdb5f4f90acb1452221a5351116c7c4708ac865/wrapt-1.17.2-cp311-cp311-win32.whl", hash = "sha256:4afd5814270fdf6380616b321fd31435a462019d834f83c8611a0ce7484c7317", size = 36419 },
-    { url = "https://files.pythonhosted.org/packages/47/f8/fb1773491a253cbc123c5d5dc15c86041f746ed30416535f2a8df1f4a392/wrapt-1.17.2-cp311-cp311-win_amd64.whl", hash = "sha256:acc130bc0375999da18e3d19e5a86403667ac0c4042a094fefb7eec8ebac7cf3", size = 38773 },
-    { url = "https://files.pythonhosted.org/packages/a1/bd/ab55f849fd1f9a58ed7ea47f5559ff09741b25f00c191231f9f059c83949/wrapt-1.17.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d5e2439eecc762cd85e7bd37161d4714aa03a33c5ba884e26c81559817ca0925", size = 53799 },
-    { url = "https://files.pythonhosted.org/packages/53/18/75ddc64c3f63988f5a1d7e10fb204ffe5762bc663f8023f18ecaf31a332e/wrapt-1.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fc7cb4c1c744f8c05cd5f9438a3caa6ab94ce8344e952d7c45a8ed59dd88392", size = 38821 },
-    { url = "https://files.pythonhosted.org/packages/48/2a/97928387d6ed1c1ebbfd4efc4133a0633546bec8481a2dd5ec961313a1c7/wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fdbdb757d5390f7c675e558fd3186d590973244fab0c5fe63d373ade3e99d40", size = 38919 },
-    { url = "https://files.pythonhosted.org/packages/73/54/3bfe5a1febbbccb7a2f77de47b989c0b85ed3a6a41614b104204a788c20e/wrapt-1.17.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bb1d0dbf99411f3d871deb6faa9aabb9d4e744d67dcaaa05399af89d847a91d", size = 88721 },
-    { url = "https://files.pythonhosted.org/packages/25/cb/7262bc1b0300b4b64af50c2720ef958c2c1917525238d661c3e9a2b71b7b/wrapt-1.17.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d18a4865f46b8579d44e4fe1e2bcbc6472ad83d98e22a26c963d46e4c125ef0b", size = 80899 },
-    { url = "https://files.pythonhosted.org/packages/2a/5a/04cde32b07a7431d4ed0553a76fdb7a61270e78c5fd5a603e190ac389f14/wrapt-1.17.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc570b5f14a79734437cb7b0500376b6b791153314986074486e0b0fa8d71d98", size = 89222 },
-    { url = "https://files.pythonhosted.org/packages/09/28/2e45a4f4771fcfb109e244d5dbe54259e970362a311b67a965555ba65026/wrapt-1.17.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6d9187b01bebc3875bac9b087948a2bccefe464a7d8f627cf6e48b1bbae30f82", size = 86707 },
-    { url = "https://files.pythonhosted.org/packages/c6/d2/dcb56bf5f32fcd4bd9aacc77b50a539abdd5b6536872413fd3f428b21bed/wrapt-1.17.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e8659775f1adf02eb1e6f109751268e493c73716ca5761f8acb695e52a756ae", size = 79685 },
-    { url = "https://files.pythonhosted.org/packages/80/4e/eb8b353e36711347893f502ce91c770b0b0929f8f0bed2670a6856e667a9/wrapt-1.17.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8b2816ebef96d83657b56306152a93909a83f23994f4b30ad4573b00bd11bb9", size = 87567 },
-    { url = "https://files.pythonhosted.org/packages/17/27/4fe749a54e7fae6e7146f1c7d914d28ef599dacd4416566c055564080fe2/wrapt-1.17.2-cp312-cp312-win32.whl", hash = "sha256:468090021f391fe0056ad3e807e3d9034e0fd01adcd3bdfba977b6fdf4213ea9", size = 36672 },
-    { url = "https://files.pythonhosted.org/packages/15/06/1dbf478ea45c03e78a6a8c4be4fdc3c3bddea5c8de8a93bc971415e47f0f/wrapt-1.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:ec89ed91f2fa8e3f52ae53cd3cf640d6feff92ba90d62236a81e4e563ac0e991", size = 38865 },
-    { url = "https://files.pythonhosted.org/packages/ce/b9/0ffd557a92f3b11d4c5d5e0c5e4ad057bd9eb8586615cdaf901409920b14/wrapt-1.17.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6ed6ffac43aecfe6d86ec5b74b06a5be33d5bb9243d055141e8cabb12aa08125", size = 53800 },
-    { url = "https://files.pythonhosted.org/packages/c0/ef/8be90a0b7e73c32e550c73cfb2fa09db62234227ece47b0e80a05073b375/wrapt-1.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35621ae4c00e056adb0009f8e86e28eb4a41a4bfa8f9bfa9fca7d343fe94f998", size = 38824 },
-    { url = "https://files.pythonhosted.org/packages/36/89/0aae34c10fe524cce30fe5fc433210376bce94cf74d05b0d68344c8ba46e/wrapt-1.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a604bf7a053f8362d27eb9fefd2097f82600b856d5abe996d623babd067b1ab5", size = 38920 },
-    { url = "https://files.pythonhosted.org/packages/3b/24/11c4510de906d77e0cfb5197f1b1445d4fec42c9a39ea853d482698ac681/wrapt-1.17.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cbabee4f083b6b4cd282f5b817a867cf0b1028c54d445b7ec7cfe6505057cf8", size = 88690 },
-    { url = "https://files.pythonhosted.org/packages/71/d7/cfcf842291267bf455b3e266c0c29dcb675b5540ee8b50ba1699abf3af45/wrapt-1.17.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49703ce2ddc220df165bd2962f8e03b84c89fee2d65e1c24a7defff6f988f4d6", size = 80861 },
-    { url = "https://files.pythonhosted.org/packages/d5/66/5d973e9f3e7370fd686fb47a9af3319418ed925c27d72ce16b791231576d/wrapt-1.17.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8112e52c5822fc4253f3901b676c55ddf288614dc7011634e2719718eaa187dc", size = 89174 },
-    { url = "https://files.pythonhosted.org/packages/a7/d3/8e17bb70f6ae25dabc1aaf990f86824e4fd98ee9cadf197054e068500d27/wrapt-1.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fee687dce376205d9a494e9c121e27183b2a3df18037f89d69bd7b35bcf59e2", size = 86721 },
-    { url = "https://files.pythonhosted.org/packages/6f/54/f170dfb278fe1c30d0ff864513cff526d624ab8de3254b20abb9cffedc24/wrapt-1.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:18983c537e04d11cf027fbb60a1e8dfd5190e2b60cc27bc0808e653e7b218d1b", size = 79763 },
-    { url = "https://files.pythonhosted.org/packages/4a/98/de07243751f1c4a9b15c76019250210dd3486ce098c3d80d5f729cba029c/wrapt-1.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:703919b1633412ab54bcf920ab388735832fdcb9f9a00ae49387f0fe67dad504", size = 87585 },
-    { url = "https://files.pythonhosted.org/packages/f9/f0/13925f4bd6548013038cdeb11ee2cbd4e37c30f8bfd5db9e5a2a370d6e20/wrapt-1.17.2-cp313-cp313-win32.whl", hash = "sha256:abbb9e76177c35d4e8568e58650aa6926040d6a9f6f03435b7a522bf1c487f9a", size = 36676 },
-    { url = "https://files.pythonhosted.org/packages/bf/ae/743f16ef8c2e3628df3ddfd652b7d4c555d12c84b53f3d8218498f4ade9b/wrapt-1.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:69606d7bb691b50a4240ce6b22ebb319c1cfb164e5f6569835058196e0f3a845", size = 38871 },
-    { url = "https://files.pythonhosted.org/packages/3d/bc/30f903f891a82d402ffb5fda27ec1d621cc97cb74c16fea0b6141f1d4e87/wrapt-1.17.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a721d3c943dae44f8e243b380cb645a709ba5bd35d3ad27bc2ed947e9c68192", size = 56312 },
-    { url = "https://files.pythonhosted.org/packages/8a/04/c97273eb491b5f1c918857cd26f314b74fc9b29224521f5b83f872253725/wrapt-1.17.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:766d8bbefcb9e00c3ac3b000d9acc51f1b399513f44d77dfe0eb026ad7c9a19b", size = 40062 },
-    { url = "https://files.pythonhosted.org/packages/4e/ca/3b7afa1eae3a9e7fefe499db9b96813f41828b9fdb016ee836c4c379dadb/wrapt-1.17.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e496a8ce2c256da1eb98bd15803a79bee00fc351f5dfb9ea82594a3f058309e0", size = 40155 },
-    { url = "https://files.pythonhosted.org/packages/89/be/7c1baed43290775cb9030c774bc53c860db140397047cc49aedaf0a15477/wrapt-1.17.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d615e4fe22f4ad3528448c193b218e077656ca9ccb22ce2cb20db730f8d306", size = 113471 },
-    { url = "https://files.pythonhosted.org/packages/32/98/4ed894cf012b6d6aae5f5cc974006bdeb92f0241775addad3f8cd6ab71c8/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5aaeff38654462bc4b09023918b7f21790efb807f54c000a39d41d69cf552cb", size = 101208 },
-    { url = "https://files.pythonhosted.org/packages/ea/fd/0c30f2301ca94e655e5e057012e83284ce8c545df7661a78d8bfca2fac7a/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7d15bbd2bc99e92e39f49a04653062ee6085c0e18b3b7512a4f2fe91f2d681", size = 109339 },
-    { url = "https://files.pythonhosted.org/packages/75/56/05d000de894c4cfcb84bcd6b1df6214297b8089a7bd324c21a4765e49b14/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e3890b508a23299083e065f435a492b5435eba6e304a7114d2f919d400888cc6", size = 110232 },
-    { url = "https://files.pythonhosted.org/packages/53/f8/c3f6b2cf9b9277fb0813418e1503e68414cd036b3b099c823379c9575e6d/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8c8b293cd65ad716d13d8dd3624e42e5a19cc2a2f1acc74b30c2c13f15cb61a6", size = 100476 },
-    { url = "https://files.pythonhosted.org/packages/a7/b1/0bb11e29aa5139d90b770ebbfa167267b1fc548d2302c30c8f7572851738/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c82b8785d98cdd9fed4cac84d765d234ed3251bd6afe34cb7ac523cb93e8b4f", size = 106377 },
-    { url = "https://files.pythonhosted.org/packages/6a/e1/0122853035b40b3f333bbb25f1939fc1045e21dd518f7f0922b60c156f7c/wrapt-1.17.2-cp313-cp313t-win32.whl", hash = "sha256:13e6afb7fe71fe7485a4550a8844cc9ffbe263c0f1a1eea569bc7091d4898555", size = 37986 },
-    { url = "https://files.pythonhosted.org/packages/09/5e/1655cf481e079c1f22d0cabdd4e51733679932718dc23bf2db175f329b76/wrapt-1.17.2-cp313-cp313t-win_amd64.whl", hash = "sha256:eaf675418ed6b3b31c7a989fd007fa7c3be66ce14e5c3b27336383604c9da85c", size = 40750 },
-    { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594 },
-]
-
-[[package]]
-name = "yarl"
-version = "1.20.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "idna" },
-    { name = "multidict" },
-    { name = "propcache" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/62/51/c0edba5219027f6eab262e139f73e2417b0f4efffa23bf562f6e18f76ca5/yarl-1.20.0.tar.gz", hash = "sha256:686d51e51ee5dfe62dec86e4866ee0e9ed66df700d55c828a615640adc885307", size = 185258 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/60/82/a59d8e21b20ffc836775fa7daedac51d16bb8f3010c4fcb495c4496aa922/yarl-1.20.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fdb5204d17cb32b2de2d1e21c7461cabfacf17f3645e4b9039f210c5d3378bf3", size = 145178 },
-    { url = "https://files.pythonhosted.org/packages/ba/81/315a3f6f95947cfbf37c92d6fbce42a1a6207b6c38e8c2b452499ec7d449/yarl-1.20.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eaddd7804d8e77d67c28d154ae5fab203163bd0998769569861258e525039d2a", size = 96859 },
-    { url = "https://files.pythonhosted.org/packages/ad/17/9b64e575583158551b72272a1023cdbd65af54fe13421d856b2850a6ddb7/yarl-1.20.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:634b7ba6b4a85cf67e9df7c13a7fb2e44fa37b5d34501038d174a63eaac25ee2", size = 94647 },
-    { url = "https://files.pythonhosted.org/packages/2c/29/8f291e7922a58a21349683f6120a85701aeefaa02e9f7c8a2dc24fe3f431/yarl-1.20.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d409e321e4addf7d97ee84162538c7258e53792eb7c6defd0c33647d754172e", size = 355788 },
-    { url = "https://files.pythonhosted.org/packages/26/6d/b4892c80b805c42c228c6d11e03cafabf81662d371b0853e7f0f513837d5/yarl-1.20.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ea52f7328a36960ba3231c6677380fa67811b414798a6e071c7085c57b6d20a9", size = 344613 },
-    { url = "https://files.pythonhosted.org/packages/d7/0e/517aa28d3f848589bae9593717b063a544b86ba0a807d943c70f48fcf3bb/yarl-1.20.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c8703517b924463994c344dcdf99a2d5ce9eca2b6882bb640aa555fb5efc706a", size = 370953 },
-    { url = "https://files.pythonhosted.org/packages/5f/9b/5bd09d2f1ad6e6f7c2beae9e50db78edd2cca4d194d227b958955573e240/yarl-1.20.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:077989b09ffd2f48fb2d8f6a86c5fef02f63ffe6b1dd4824c76de7bb01e4f2e2", size = 369204 },
-    { url = "https://files.pythonhosted.org/packages/9c/85/d793a703cf4bd0d4cd04e4b13cc3d44149470f790230430331a0c1f52df5/yarl-1.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0acfaf1da020253f3533526e8b7dd212838fdc4109959a2c53cafc6db611bff2", size = 358108 },
-    { url = "https://files.pythonhosted.org/packages/6f/54/b6c71e13549c1f6048fbc14ce8d930ac5fb8bafe4f1a252e621a24f3f1f9/yarl-1.20.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b4230ac0b97ec5eeb91d96b324d66060a43fd0d2a9b603e3327ed65f084e41f8", size = 346610 },
-    { url = "https://files.pythonhosted.org/packages/a0/1a/d6087d58bdd0d8a2a37bbcdffac9d9721af6ebe50d85304d9f9b57dfd862/yarl-1.20.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a6a1e6ae21cdd84011c24c78d7a126425148b24d437b5702328e4ba640a8902", size = 365378 },
-    { url = "https://files.pythonhosted.org/packages/02/84/e25ddff4cbc001dbc4af76f8d41a3e23818212dd1f0a52044cbc60568872/yarl-1.20.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:86de313371ec04dd2531f30bc41a5a1a96f25a02823558ee0f2af0beaa7ca791", size = 356919 },
-    { url = "https://files.pythonhosted.org/packages/04/76/898ae362353bf8f64636495d222c8014c8e5267df39b1a9fe1e1572fb7d0/yarl-1.20.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:dd59c9dd58ae16eaa0f48c3d0cbe6be8ab4dc7247c3ff7db678edecbaf59327f", size = 364248 },
-    { url = "https://files.pythonhosted.org/packages/1b/b0/9d9198d83a622f1c40fdbf7bd13b224a6979f2e1fc2cf50bfb1d8773c495/yarl-1.20.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a0bc5e05f457b7c1994cc29e83b58f540b76234ba6b9648a4971ddc7f6aa52da", size = 378418 },
-    { url = "https://files.pythonhosted.org/packages/c7/ce/1f50c1cc594cf5d3f5bf4a9b616fca68680deaec8ad349d928445ac52eb8/yarl-1.20.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c9471ca18e6aeb0e03276b5e9b27b14a54c052d370a9c0c04a68cefbd1455eb4", size = 383850 },
-    { url = "https://files.pythonhosted.org/packages/89/1e/a59253a87b35bfec1a25bb5801fb69943330b67cfd266278eb07e0609012/yarl-1.20.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:40ed574b4df723583a26c04b298b283ff171bcc387bc34c2683235e2487a65a5", size = 381218 },
-    { url = "https://files.pythonhosted.org/packages/85/b0/26f87df2b3044b0ef1a7cf66d321102bdca091db64c5ae853fcb2171c031/yarl-1.20.0-cp311-cp311-win32.whl", hash = "sha256:db243357c6c2bf3cd7e17080034ade668d54ce304d820c2a58514a4e51d0cfd6", size = 86606 },
-    { url = "https://files.pythonhosted.org/packages/33/46/ca335c2e1f90446a77640a45eeb1cd8f6934f2c6e4df7db0f0f36ef9f025/yarl-1.20.0-cp311-cp311-win_amd64.whl", hash = "sha256:8c12cd754d9dbd14204c328915e23b0c361b88f3cffd124129955e60a4fbfcfb", size = 93374 },
-    { url = "https://files.pythonhosted.org/packages/c3/e8/3efdcb83073df978bb5b1a9cc0360ce596680e6c3fac01f2a994ccbb8939/yarl-1.20.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e06b9f6cdd772f9b665e5ba8161968e11e403774114420737f7884b5bd7bdf6f", size = 147089 },
-    { url = "https://files.pythonhosted.org/packages/60/c3/9e776e98ea350f76f94dd80b408eaa54e5092643dbf65fd9babcffb60509/yarl-1.20.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b9ae2fbe54d859b3ade40290f60fe40e7f969d83d482e84d2c31b9bff03e359e", size = 97706 },
-    { url = "https://files.pythonhosted.org/packages/0c/5b/45cdfb64a3b855ce074ae607b9fc40bc82e7613b94e7612b030255c93a09/yarl-1.20.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6d12b8945250d80c67688602c891237994d203d42427cb14e36d1a732eda480e", size = 95719 },
-    { url = "https://files.pythonhosted.org/packages/2d/4e/929633b249611eeed04e2f861a14ed001acca3ef9ec2a984a757b1515889/yarl-1.20.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:087e9731884621b162a3e06dc0d2d626e1542a617f65ba7cc7aeab279d55ad33", size = 343972 },
-    { url = "https://files.pythonhosted.org/packages/49/fd/047535d326c913f1a90407a3baf7ff535b10098611eaef2c527e32e81ca1/yarl-1.20.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:69df35468b66c1a6e6556248e6443ef0ec5f11a7a4428cf1f6281f1879220f58", size = 339639 },
-    { url = "https://files.pythonhosted.org/packages/48/2f/11566f1176a78f4bafb0937c0072410b1b0d3640b297944a6a7a556e1d0b/yarl-1.20.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b2992fe29002fd0d4cbaea9428b09af9b8686a9024c840b8a2b8f4ea4abc16f", size = 353745 },
-    { url = "https://files.pythonhosted.org/packages/26/17/07dfcf034d6ae8837b33988be66045dd52f878dfb1c4e8f80a7343f677be/yarl-1.20.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c903e0b42aab48abfbac668b5a9d7b6938e721a6341751331bcd7553de2dcae", size = 354178 },
-    { url = "https://files.pythonhosted.org/packages/15/45/212604d3142d84b4065d5f8cab6582ed3d78e4cc250568ef2a36fe1cf0a5/yarl-1.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf099e2432131093cc611623e0b0bcc399b8cddd9a91eded8bfb50402ec35018", size = 349219 },
-    { url = "https://files.pythonhosted.org/packages/e6/e0/a10b30f294111c5f1c682461e9459935c17d467a760c21e1f7db400ff499/yarl-1.20.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8a7f62f5dc70a6c763bec9ebf922be52aa22863d9496a9a30124d65b489ea672", size = 337266 },
-    { url = "https://files.pythonhosted.org/packages/33/a6/6efa1d85a675d25a46a167f9f3e80104cde317dfdf7f53f112ae6b16a60a/yarl-1.20.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:54ac15a8b60382b2bcefd9a289ee26dc0920cf59b05368c9b2b72450751c6eb8", size = 360873 },
-    { url = "https://files.pythonhosted.org/packages/77/67/c8ab718cb98dfa2ae9ba0f97bf3cbb7d45d37f13fe1fbad25ac92940954e/yarl-1.20.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:25b3bc0763a7aca16a0f1b5e8ef0f23829df11fb539a1b70476dcab28bd83da7", size = 360524 },
-    { url = "https://files.pythonhosted.org/packages/bd/e8/c3f18660cea1bc73d9f8a2b3ef423def8dadbbae6c4afabdb920b73e0ead/yarl-1.20.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b2586e36dc070fc8fad6270f93242124df68b379c3a251af534030a4a33ef594", size = 365370 },
-    { url = "https://files.pythonhosted.org/packages/c9/99/33f3b97b065e62ff2d52817155a89cfa030a1a9b43fee7843ef560ad9603/yarl-1.20.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:866349da9d8c5290cfefb7fcc47721e94de3f315433613e01b435473be63daa6", size = 373297 },
-    { url = "https://files.pythonhosted.org/packages/3d/89/7519e79e264a5f08653d2446b26d4724b01198a93a74d2e259291d538ab1/yarl-1.20.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:33bb660b390a0554d41f8ebec5cd4475502d84104b27e9b42f5321c5192bfcd1", size = 378771 },
-    { url = "https://files.pythonhosted.org/packages/3a/58/6c460bbb884abd2917c3eef6f663a4a873f8dc6f498561fc0ad92231c113/yarl-1.20.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:737e9f171e5a07031cbee5e9180f6ce21a6c599b9d4b2c24d35df20a52fabf4b", size = 375000 },
-    { url = "https://files.pythonhosted.org/packages/3b/2a/dd7ed1aa23fea996834278d7ff178f215b24324ee527df53d45e34d21d28/yarl-1.20.0-cp312-cp312-win32.whl", hash = "sha256:839de4c574169b6598d47ad61534e6981979ca2c820ccb77bf70f4311dd2cc64", size = 86355 },
-    { url = "https://files.pythonhosted.org/packages/ca/c6/333fe0338305c0ac1c16d5aa7cc4841208d3252bbe62172e0051006b5445/yarl-1.20.0-cp312-cp312-win_amd64.whl", hash = "sha256:3d7dbbe44b443b0c4aa0971cb07dcb2c2060e4a9bf8d1301140a33a93c98e18c", size = 92904 },
-    { url = "https://files.pythonhosted.org/packages/0f/6f/514c9bff2900c22a4f10e06297714dbaf98707143b37ff0bcba65a956221/yarl-1.20.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2137810a20b933b1b1b7e5cf06a64c3ed3b4747b0e5d79c9447c00db0e2f752f", size = 145030 },
-    { url = "https://files.pythonhosted.org/packages/4e/9d/f88da3fa319b8c9c813389bfb3463e8d777c62654c7168e580a13fadff05/yarl-1.20.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:447c5eadd750db8389804030d15f43d30435ed47af1313303ed82a62388176d3", size = 96894 },
-    { url = "https://files.pythonhosted.org/packages/cd/57/92e83538580a6968b2451d6c89c5579938a7309d4785748e8ad42ddafdce/yarl-1.20.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42fbe577272c203528d402eec8bf4b2d14fd49ecfec92272334270b850e9cd7d", size = 94457 },
-    { url = "https://files.pythonhosted.org/packages/e9/ee/7ee43bd4cf82dddd5da97fcaddb6fa541ab81f3ed564c42f146c83ae17ce/yarl-1.20.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18e321617de4ab170226cd15006a565d0fa0d908f11f724a2c9142d6b2812ab0", size = 343070 },
-    { url = "https://files.pythonhosted.org/packages/4a/12/b5eccd1109e2097bcc494ba7dc5de156e41cf8309fab437ebb7c2b296ce3/yarl-1.20.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4345f58719825bba29895011e8e3b545e6e00257abb984f9f27fe923afca2501", size = 337739 },
-    { url = "https://files.pythonhosted.org/packages/7d/6b/0eade8e49af9fc2585552f63c76fa59ef469c724cc05b29519b19aa3a6d5/yarl-1.20.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5d9b980d7234614bc4674468ab173ed77d678349c860c3af83b1fffb6a837ddc", size = 351338 },
-    { url = "https://files.pythonhosted.org/packages/45/cb/aaaa75d30087b5183c7b8a07b4fb16ae0682dd149a1719b3a28f54061754/yarl-1.20.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af4baa8a445977831cbaa91a9a84cc09debb10bc8391f128da2f7bd070fc351d", size = 353636 },
-    { url = "https://files.pythonhosted.org/packages/98/9d/d9cb39ec68a91ba6e66fa86d97003f58570327d6713833edf7ad6ce9dde5/yarl-1.20.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:123393db7420e71d6ce40d24885a9e65eb1edefc7a5228db2d62bcab3386a5c0", size = 348061 },
-    { url = "https://files.pythonhosted.org/packages/72/6b/103940aae893d0cc770b4c36ce80e2ed86fcb863d48ea80a752b8bda9303/yarl-1.20.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ab47acc9332f3de1b39e9b702d9c916af7f02656b2a86a474d9db4e53ef8fd7a", size = 334150 },
-    { url = "https://files.pythonhosted.org/packages/ef/b2/986bd82aa222c3e6b211a69c9081ba46484cffa9fab2a5235e8d18ca7a27/yarl-1.20.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4a34c52ed158f89876cba9c600b2c964dfc1ca52ba7b3ab6deb722d1d8be6df2", size = 362207 },
-    { url = "https://files.pythonhosted.org/packages/14/7c/63f5922437b873795d9422cbe7eb2509d4b540c37ae5548a4bb68fd2c546/yarl-1.20.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:04d8cfb12714158abf2618f792c77bc5c3d8c5f37353e79509608be4f18705c9", size = 361277 },
-    { url = "https://files.pythonhosted.org/packages/81/83/450938cccf732466953406570bdb42c62b5ffb0ac7ac75a1f267773ab5c8/yarl-1.20.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7dc63ad0d541c38b6ae2255aaa794434293964677d5c1ec5d0116b0e308031f5", size = 364990 },
-    { url = "https://files.pythonhosted.org/packages/b4/de/af47d3a47e4a833693b9ec8e87debb20f09d9fdc9139b207b09a3e6cbd5a/yarl-1.20.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f9d02b591a64e4e6ca18c5e3d925f11b559c763b950184a64cf47d74d7e41877", size = 374684 },
-    { url = "https://files.pythonhosted.org/packages/62/0b/078bcc2d539f1faffdc7d32cb29a2d7caa65f1a6f7e40795d8485db21851/yarl-1.20.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:95fc9876f917cac7f757df80a5dda9de59d423568460fe75d128c813b9af558e", size = 382599 },
-    { url = "https://files.pythonhosted.org/packages/74/a9/4fdb1a7899f1fb47fd1371e7ba9e94bff73439ce87099d5dd26d285fffe0/yarl-1.20.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bb769ae5760cd1c6a712135ee7915f9d43f11d9ef769cb3f75a23e398a92d384", size = 378573 },
-    { url = "https://files.pythonhosted.org/packages/fd/be/29f5156b7a319e4d2e5b51ce622b4dfb3aa8d8204cd2a8a339340fbfad40/yarl-1.20.0-cp313-cp313-win32.whl", hash = "sha256:70e0c580a0292c7414a1cead1e076c9786f685c1fc4757573d2967689b370e62", size = 86051 },
-    { url = "https://files.pythonhosted.org/packages/52/56/05fa52c32c301da77ec0b5f63d2d9605946fe29defacb2a7ebd473c23b81/yarl-1.20.0-cp313-cp313-win_amd64.whl", hash = "sha256:4c43030e4b0af775a85be1fa0433119b1565673266a70bf87ef68a9d5ba3174c", size = 92742 },
-    { url = "https://files.pythonhosted.org/packages/d4/2f/422546794196519152fc2e2f475f0e1d4d094a11995c81a465faf5673ffd/yarl-1.20.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b6c4c3d0d6a0ae9b281e492b1465c72de433b782e6b5001c8e7249e085b69051", size = 163575 },
-    { url = "https://files.pythonhosted.org/packages/90/fc/67c64ddab6c0b4a169d03c637fb2d2a212b536e1989dec8e7e2c92211b7f/yarl-1.20.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8681700f4e4df891eafa4f69a439a6e7d480d64e52bf460918f58e443bd3da7d", size = 106121 },
-    { url = "https://files.pythonhosted.org/packages/6d/00/29366b9eba7b6f6baed7d749f12add209b987c4cfbfa418404dbadc0f97c/yarl-1.20.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:84aeb556cb06c00652dbf87c17838eb6d92cfd317799a8092cee0e570ee11229", size = 103815 },
-    { url = "https://files.pythonhosted.org/packages/28/f4/a2a4c967c8323c03689383dff73396281ced3b35d0ed140580825c826af7/yarl-1.20.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f166eafa78810ddb383e930d62e623d288fb04ec566d1b4790099ae0f31485f1", size = 408231 },
-    { url = "https://files.pythonhosted.org/packages/0f/a1/66f7ffc0915877d726b70cc7a896ac30b6ac5d1d2760613603b022173635/yarl-1.20.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5d3d6d14754aefc7a458261027a562f024d4f6b8a798adb472277f675857b1eb", size = 390221 },
-    { url = "https://files.pythonhosted.org/packages/41/15/cc248f0504610283271615e85bf38bc014224122498c2016d13a3a1b8426/yarl-1.20.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2a8f64df8ed5d04c51260dbae3cc82e5649834eebea9eadfd829837b8093eb00", size = 411400 },
-    { url = "https://files.pythonhosted.org/packages/5c/af/f0823d7e092bfb97d24fce6c7269d67fcd1aefade97d0a8189c4452e4d5e/yarl-1.20.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4d9949eaf05b4d30e93e4034a7790634bbb41b8be2d07edd26754f2e38e491de", size = 411714 },
-    { url = "https://files.pythonhosted.org/packages/83/70/be418329eae64b9f1b20ecdaac75d53aef098797d4c2299d82ae6f8e4663/yarl-1.20.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c366b254082d21cc4f08f522ac201d0d83a8b8447ab562732931d31d80eb2a5", size = 404279 },
-    { url = "https://files.pythonhosted.org/packages/19/f5/52e02f0075f65b4914eb890eea1ba97e6fd91dd821cc33a623aa707b2f67/yarl-1.20.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91bc450c80a2e9685b10e34e41aef3d44ddf99b3a498717938926d05ca493f6a", size = 384044 },
-    { url = "https://files.pythonhosted.org/packages/6a/36/b0fa25226b03d3f769c68d46170b3e92b00ab3853d73127273ba22474697/yarl-1.20.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9c2aa4387de4bc3a5fe158080757748d16567119bef215bec643716b4fbf53f9", size = 416236 },
-    { url = "https://files.pythonhosted.org/packages/cb/3a/54c828dd35f6831dfdd5a79e6c6b4302ae2c5feca24232a83cb75132b205/yarl-1.20.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:d2cbca6760a541189cf87ee54ff891e1d9ea6406079c66341008f7ef6ab61145", size = 402034 },
-    { url = "https://files.pythonhosted.org/packages/10/97/c7bf5fba488f7e049f9ad69c1b8fdfe3daa2e8916b3d321aa049e361a55a/yarl-1.20.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:798a5074e656f06b9fad1a162be5a32da45237ce19d07884d0b67a0aa9d5fdda", size = 407943 },
-    { url = "https://files.pythonhosted.org/packages/fd/a4/022d2555c1e8fcff08ad7f0f43e4df3aba34f135bff04dd35d5526ce54ab/yarl-1.20.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f106e75c454288472dbe615accef8248c686958c2e7dd3b8d8ee2669770d020f", size = 423058 },
-    { url = "https://files.pythonhosted.org/packages/4c/f6/0873a05563e5df29ccf35345a6ae0ac9e66588b41fdb7043a65848f03139/yarl-1.20.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3b60a86551669c23dc5445010534d2c5d8a4e012163218fc9114e857c0586fdd", size = 423792 },
-    { url = "https://files.pythonhosted.org/packages/9e/35/43fbbd082708fa42e923f314c24f8277a28483d219e049552e5007a9aaca/yarl-1.20.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e429857e341d5e8e15806118e0294f8073ba9c4580637e59ab7b238afca836f", size = 422242 },
-    { url = "https://files.pythonhosted.org/packages/ed/f7/f0f2500cf0c469beb2050b522c7815c575811627e6d3eb9ec7550ddd0bfe/yarl-1.20.0-cp313-cp313t-win32.whl", hash = "sha256:65a4053580fe88a63e8e4056b427224cd01edfb5f951498bfefca4052f0ce0ac", size = 93816 },
-    { url = "https://files.pythonhosted.org/packages/3f/93/f73b61353b2a699d489e782c3f5998b59f974ec3156a2050a52dfd7e8946/yarl-1.20.0-cp313-cp313t-win_amd64.whl", hash = "sha256:53b2da3a6ca0a541c1ae799c349788d480e5144cac47dba0266c7cb6c76151fe", size = 101093 },
-    { url = "https://files.pythonhosted.org/packages/ea/1f/70c57b3d7278e94ed22d85e09685d3f0a38ebdd8c5c73b65ba4c0d0fe002/yarl-1.20.0-py3-none-any.whl", hash = "sha256:5d0fe6af927a47a230f31e6004621fd0959eaa915fc62acfafa67ff7229a3124", size = 46124 },
-]