Merge pull request #263 from specklesystems/bilal/cnx-1770-set-viewport-display-color-in-addition-to-material-color

Set Viewport Display color of materials

.circleci/config.yml

@@ -1,142 +1,17 @@
 version: 2.1
 
-orbs:
-  python: circleci/python@1.3.2
-  # Using windows for builds
-  win: circleci/windows@2.4.0
-  # Upload artifacts to s3
-  aws-s3: circleci/aws-s3@2.0.0
-
+# Define the jobs we want to run for this project
 jobs:
-  build-connector: # Reusable job for basic connectors
-    executor:
-      name: win/default # comes with python 3.7.3
-      shell: cmd.exe
-    parameters:
-      slug:
-        type: string
-        default: ""
-    steps:
-      - checkout
-      - attach_workspace:
-          at: ./
-      - run: 
-          name: Install specklepy with python 3.7
-          shell: powershell.exe
-          command: |
-            $pyarr=(python --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            python -m pip install --target=./modules-$pyver specklepy==$specklepy
-      - run: 
-          name: Install python 3.9 and specklepy 
-          shell: powershell.exe
-          command: |
-            choco install python --version=3.9.2
-            $pyarr=(C:\Python39\python.exe --version).split(' ')[1].split('.')
-            $pyver=($pyarr[0..1] -join '.')
-            echo "using python version:" $pyver
-            $specklepy=(python patch_version.py)
-            C:\Python39\python.exe -m pip install --target=./modules-$pyver specklepy==$specklepy
-      - run:
-          name: Patch
-          shell: powershell.exe
-          command:
-            | # If no tag, use 0.0.0.1 and don't make any YML (for testing only!)
-            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "0.0.1" } else { $env:CIRCLE_TAG }
-            $semver = $tag.replace("-beta","")
-            $version = "$($semver).$($env:CIRCLE_BUILD_NUM)"
-            $channel = "latest"
-            if($tag -like "*-beta") { $channel = "beta" }
-            # only create the yml if we have a tag
-            New-Item -Force "speckle-sharp-ci-tools/Installers/blender/$channel.yml" -ItemType File -Value "version: $version"
-            echo $version
-            ls
-            python patch_version.py $version
-            speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\blender.iss
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools/Installers
-
-  install-specklepy: # due to ujson dep, we need to match the py version to the install
+  build:
     docker:
-      - image: "cimg/python:<<parameters.tag>>"
-    parameters:
-      tag:
-        default: "3.9"
-        type: string
+      - image: cimg/base:2023.03
     steps:
-      - checkout
-      - run:
-          name: upgrade pip and install specklepy
-          command: |
-            specklepyver=$(python patch_version.py)
-            echo installing specklepy $specklepyver
-            python -m pip install --target=./modules-<<parameters.tag>> specklepy==$specklepyver
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - modules-*
-          
-  get-ci-tools: # Clones our ci tools and persists them to the workspace
-    docker:
-      - image: cimg/base:2021.01
-    steps:
-      - run: # Could not get ssh to work, so using a personal token
-          name: Clone
-          command: git clone https://$GITHUB_TOKEN@github.com/specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools
-
-  deploy: # Uploads all installers found to S3
-    docker:
-      - image: cimg/base:2021.01
-    steps:
-      - attach_workspace:
-          at: ./
-      - run:
-          name: List contents
-          command: ls -R speckle-sharp-ci-tools/Installers
-      - aws-s3/copy:
-          arguments: "--recursive --endpoint=https://$SPACES_REGION.digitaloceanspaces.com --acl public-read"
-          aws-access-key-id: SPACES_KEY
-          aws-region: SPACES_REGION
-          aws-secret-access-key: SPACES_SECRET
-          from: '"speckle-sharp-ci-tools/Installers/"'
-          to: s3://speckle-releases/installers/
+      - run: echo "so long and thanks for all the fish"
 
+# Orchestrate our job run sequence
 workflows:
-  main:
+  build_and_test:
+    when:
+      false
     jobs:
-      - get-ci-tools:
-          filters:
-            tags:
-              only: /.*/
-            branches:
-              only:
-                - main
-                - /ci\/.*/
-      - build-connector:
-          slug: blender
-          requires:
-            - get-ci-tools
-          filters:
-            tags:
-              only: /.*/
-            branches:
-              only:
-                - main
-                - /ci\/.*/
-      - deploy:
-          requires:
-            - get-ci-tools
-            - build-connector
-          filters:
-            tags:
-              only: /[0-9]+(\.[0-9]+)*/
-            branches:
-              ignore: /.*/ # For testing only! /ci\/.*/
+      - build

.github/workflows/close-issue.yml

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

.github/workflows/open-issue.yml

@@ -1,50 +0,0 @@
-name: Move new issues into Project
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  track_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ORGANIZATION: specklesystems
-          PROJECT_NUMBER: 9
-        run: |
-          gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            query($org: String!, $number: Int!) {
-              organization(login: $org){
-                projectNext(number: $number) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' -f org=$ORGANIZATION -F number=$PROJECT_NUMBER > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-     
-      - name: Add Issue to project
-        env:
-          GITHUB_TOKEN: ${{secrets.GHPROJECT_TOKEN}}
-          ISSUE_ID: ${{ github.event.issue.node_id }}
-        run: |
-          item_id="$( gh api graphql --header 'GraphQL-Features: projects_next_graphql' -f query='
-            mutation($project:ID!, $id:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $id}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f id=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

.github/workflows/pr.yml

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

.github/workflows/release.yml

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

@@ -10,4 +10,8 @@ __pycache__/
 # dev
 .venv
 Installers/
-modules/
+modules/
+.tool-versions
+requirements.txt
+SEMVER
+dui3/

README.md

@@ -3,7 +3,7 @@
   Speckle | Blender
 </h1>
 <h3 align="center">
-    Connector for Blender 2.92 & 2.93
+    Connector for Blender
 </h3>
 <p align="center"><b>Speckle</b> is the data infrastructure for the AEC industry.</p><br/>
 
@@ -41,42 +41,42 @@ Give Speckle a try in no time by:
 - [![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
 
 
-# Repo structure
+# 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.
-
-## Disclaimer
-This code is WIP and as such should be used with extreme caution on non-sensitive projects.
 
 ## Installation
-
-1. Place `bpy_speckle` folder in your `addons` folder. On Windows this is typically `%APPDATA%/Blender Foundation/Blender/2.80/scripts/addons`.
-2. Go to `Edit->Preferences` (Ctrl + Alt + U)
-3. Go to the `Add-ons` tab
-4. Find and enable `SpeckleBlender 2.0` in the `Scene` category. <!-- **If enabling for the first time, expect the UI to freeze for bit while it silently installs all the dependencies.** -->
-5. The Speckle UI can be found in the 3d viewport toolbar (N), under the `Speckle` tab.
+We officially support Blender 4.2 and newer, on Windows.
 
 ## Usage
-- 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 `Streams` list with available streams for the selected user.
-- Select a branch and commit from the dropdown menus.
-- Click on `Receive` to download the objects from the selected stream, branch, and commit. The stream objects will be loaded into a Blender Collection, named `<STREAM_NAME> [ <STREAM_BRANCH> @ <BRANCH_COMMIT> ]`. <!-- You can filter the stream by entering a query into the `Filter` field (i.e. `properties.weight>10` or `type="Mesh"`). -->
-- Click on `Open Stream in Web` to view the stream in your web browser.
+Once enabled in `Preferences -> Addons`,
+The Speckle connector UI can be found in the 3d viewport toolbar (N), under the `Speckle` tab.
 
-## Caveats
+- 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.
+- 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 `Open Model in Web` to view the model in your web browser.
 
-- Mesh objects are supported. Breps are imported as meshes using their `displayValue` data. 
-- Curves have limited support: `Polylines` are supported; `NurbsCurves` are supported, though they are not guaranteed to look the same; `Lines` are supported; `Arcs` are not supported, though they are very roughly approximated; `PolyCurves` are supported for linear / polyline segments and very approximate arc segments. These conversions are a point of focus for further development.
+## Supported Elements
 
-## Custom properties
+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!
 
-- **SpeckleBlender** will look for a `texture_coordinates` property and use that to create a UV layer for the imported object. These texture coordinates are a space-separated list of floats (`[u v u v u v etc...]`) that is encoded as a base64 blob. This is subject to change as **SpeckleBlender** develops.
-- 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.
-- Vertex colors are supported. The `colors` list from Speckle meshes is translated to a vertex color layer.
-- 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"`.
 
+## 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.
+
+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.
+
+Other blender addons may require dependencies that conflict with specklepy. In these cases, one or both addons may fail to load.
+If you suspect you're seeing a conflict, Please uninstall other third party addons one at a time to identify which addon is conflicting.
+
+If you find an addon that conflicts, please try using a different version of that addon (newer or older).
+
+If you can't find a version of an addon that works, please let us know on [our forums](https://speckle.community/) the name of the addon, the versions you've tried, the version of the Speckle connector you've tried, and your OS (win/mac/linux).
 
 ## Contributing
 
@@ -91,4 +91,4 @@ The Speckle Community hangs out on [the forum](https://discourse.speckle.works),
 Unless otherwise described, the code in this repository is licensed under the Apache-2.0 License. Please note that some modules, extensions or code herein might be otherwise licensed. This is indicated either in the root of the containing folder under a different license file, or in the respective file's header. If you have any questions, don't hesitate to get in touch with us via [email](mailto:hello@speckle.systems).
 
 ## Notes
-SpeckleBlender is written and maintained by [Tom Svilans](http://tomsvilans.com) ([Github](https://github.com/tsvilans)).
+Thanks to [Tom Svilans](http://tomsvilans.com) ([Github](https://github.com/tsvilans)) for the original v1 contribution!

bpy_speckle/__init__.py

@@ -1,142 +1,146 @@
-# MIT License
-
-# Copyright (c) 2018-2021 Tom Svilans
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
+# 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
+ensure_dependencies(f"Blender {bpy.app.version[0]}.{bpy.app.version[1]}")
 
 bl_info = {
-    "name": "SpeckleBlender 2.0",
+    "name": "Speckle Blender ",
     "author": "Speckle Systems",
-    "version": (0, 2, 0),
-    "blender": (2, 92, 0),
+    "version": (3, 999, 999),
+    "blender": (4, 2, 0),
     "location": "3d viewport toolbar (N), under the Speckle tab.",
-    "description": "The Speckle Connector using specklepy 2.0!",
+    "description": "The Speckle Connector using specklepy 3.x!",
     "warning": "This add-on is WIP and should be used with caution",
     "wiki_url": "https://github.com/specklesystems/speckle-blender",
     "category": "Scene",
 }
 
-import bpy
 
-"""
-Import PySpeckle and attempt install if not found
-"""
+# 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
 
-try:
-    import specklepy
-except ModuleNotFoundError as error:
-    print("Speckle not found.")
-    # TODO: Implement automatic installation of speckle and dependencies
-    # to the local Blender module folder
-
-    # from .install_dependencies import install_dependencies
-    # install_dependencies()
-
-"""
-Import SpeckleBlender classes
-"""
-
-from specklepy.api.client import SpeckleClient  # , SpeckleCache
-from specklepy.logging import metrics
-
-from bpy_speckle.ui import *
-from bpy_speckle.properties import *
-from bpy_speckle.operators import *
-from bpy_speckle.callbacks import *
-from bpy.app.handlers import persistent
-
-"""
-Add load handler to initialize Speckle when 
-loading a Blender file
-"""
-
-
-@persistent
-def load_handler(dummy):
-    bpy.ops.speckle.users_load()
-
-
-"""
-Permanent handle on callbacks
-"""
-
-callbacks = {}
-
-"""
-Add Speckle classes for registering
-"""
-
-speckle_classes = []
-speckle_classes.extend(operator_classes)
-speckle_classes.extend(property_classes)
-speckle_classes.extend(ui_classes)
-
-
-def register():
-    from bpy.utils import register_class
-
-    for cls in speckle_classes:
-        register_class(cls)
-
-    metrics.set_host_app("Blender")
-
-    """
-    Register all new properties
-    """
-
-    bpy.types.Scene.speckle = bpy.props.PointerProperty(type=SpeckleSceneSettings)
-    bpy.types.Collection.speckle = bpy.props.PointerProperty(
-        type=SpeckleCollectionSettings
+def invoke_window_manager_properties():
+    # Accounts
+    WindowManager.speckle_accounts = bpy.props.CollectionProperty(
+        type = speckle_account
     )
-    bpy.types.Object.speckle = bpy.props.PointerProperty(type=SpeckleObjectSettings)
+    WindowManager.selected_account_id = bpy.props.StringProperty()
+    # Workspaces
+    WindowManager.speckle_workspaces = bpy.props.CollectionProperty(
+        type = speckle_workspace
+    )
+    WindowManager.selected_workspace_id = bpy.props.StringProperty()
+    # Projects
+    WindowManager.speckle_projects = bpy.props.CollectionProperty(
+                type=speckle_project
+            )
+    WindowManager.selected_project_id = bpy.props.StringProperty()
+    WindowManager.selected_project_name = bpy.props.StringProperty()        
+    # Models
+    WindowManager.speckle_models = bpy.props.CollectionProperty(
+                type=speckle_model
+            )
+    WindowManager.selected_model_id = bpy.props.StringProperty()
+    WindowManager.selected_model_name = bpy.props.StringProperty()
+    # Versions
+    WindowManager.speckle_versions = bpy.props.CollectionProperty(
+            type=speckle_version
+        )
+    WindowManager.selected_version_id = bpy.props.StringProperty()
+    WindowManager.selected_version_load_option = bpy.props.StringProperty()
 
-    """
-    Add callbacks
-    """
+def save_model_cards(scene):
+    model_cards_data = [card.to_dict() for card in scene.speckle_state.model_cards]
+    scene["speckle_model_cards_data"] = json.dumps(model_cards_data)
 
-    # Callback for displaying the current user account on top of the 3d view
-    # callbacks['view3d_status'] = ((
-    #     bpy.types.SpaceView3D.draw_handler_remove, # Function pointer for removal
-    #     bpy.types.SpaceView3D.draw_handler_add(draw_speckle_info, (None, None), 'WINDOW', 'POST_PIXEL'), # Add handler
-    #     'WINDOW' # Callback space for removal
-    #     ))
+def load_model_cards(scene):
+    if "speckle_model_cards_data" in scene:
+        model_cards_data = json.loads(scene["speckle_model_cards_data"])
+        scene.speckle_state.model_cards.clear()
+        for card_data in model_cards_data:
+            card = speckle_model_card.from_dict(card_data)
+            scene.speckle_state.model_cards.add().update(card)
+
+
+# Classes to load
+classes = (
+    SPECKLE_PT_main_panel,
+    SPECKLE_OT_publish,
+    SPECKLE_OT_load,
+    SPECKLE_OT_project_selection_dialog, speckle_project, SPECKLE_UL_projects_list, speckle_workspace,
+    SPECKLE_OT_model_selection_dialog, speckle_model, SPECKLE_UL_models_list,
+    SPECKLE_OT_version_selection_dialog, speckle_version, SPECKLE_UL_versions_list,
+    SPECKLE_OT_selection_filter_dialog,
+    speckle_model_card, SPECKLE_OT_model_card_settings, SPECKLE_OT_view_in_browser, SPECKLE_OT_view_model_versions, SPECKLE_OT_delete_model_card,
+    SPECKLE_OT_select_objects,
+    SPECKLE_OT_add_account,
+    SPECKLE_OT_load_latest,
+    SPECKLE_OT_add_project_by_url,
+    speckle_account)
+
+@bpy.app.handlers.persistent
+def load_handler(dummy):
+    load_model_cards(bpy.context.scene)
+
+@bpy.app.handlers.persistent
+def save_handler(dummy):
+    save_model_cards(bpy.context.scene)
+
+# Register and Unregister
+def register():
+    icons.load_icons()
+
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    register_speckle_state() # Register SpeckleState
 
     bpy.app.handlers.load_post.append(load_handler)
+    bpy.app.handlers.save_post.append(save_handler)
 
+    invoke_window_manager_properties()
 
 def unregister():
+    icons.unload_icons()
+    unregister_speckle_state() # Unregister SpeckleState
+    for cls in classes:
+        bpy.utils.unregister_class(cls)
 
     bpy.app.handlers.load_post.remove(load_handler)
+    bpy.app.handlers.save_post.remove(save_handler)
 
-    """
-    Remove callbacks
-    """
-
-    for cb in callbacks.values():
-        cb[0](cb[1], cb[2])
-
-    from bpy.utils import unregister_class
-
-    for cls in reversed(speckle_classes):
-        unregister_class(cls)
-
-
+# Run the register function when the script is executed
 if __name__ == "__main__":
     register()

bpy_speckle/blender_manifest.toml

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

bpy_speckle/callbacks/__init__.py

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

bpy_speckle/callbacks/draw_speckle_info.py

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

bpy_speckle/callbacks/on_mesh_edit.py

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

bpy_speckle/clients.py

@@ -1,4 +0,0 @@
-"""
-Permanent handle on all user clients
-"""
-speckle_clients = []

bpy_speckle/connector/blender_operators/__init__.py

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

bpy_speckle/connector/blender_operators/add_account_button.py

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

bpy_speckle/connector/blender_operators/add_project_by_url.py

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

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

bpy_speckle/connector/blender_operators/load_latest_button.py

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

bpy_speckle/connector/blender_operators/model_card_settings.py

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

bpy_speckle/connector/blender_operators/publish_button.py

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

bpy_speckle/connector/blender_operators/select_objects.py

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

bpy_speckle/connector/operations/__init__.py

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

bpy_speckle/connector/operations/load_operation.py

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

bpy_speckle/connector/states/speckle_state.py

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

bpy_speckle/connector/ui/__init__.py

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

bpy_speckle/connector/ui/icons.py

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

bpy_speckle/connector/ui/main_panel.py

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

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

bpy_speckle/connector/ui/model_selection_dialog.py

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

bpy_speckle/connector/ui/project_selection_dialog.py

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

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

bpy_speckle/connector/ui/version_selection_dialog.py

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

bpy_speckle/connector/utils/account_manager.py

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

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

bpy_speckle/connector/utils/misc.py

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

bpy_speckle/connector/utils/model_manager.py

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

bpy_speckle/connector/utils/project_manager.py

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

@@ -0,0 +1,100 @@
+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/__init__.py

@@ -1,27 +0,0 @@
-from bpy_speckle.convert.to_native import convert_to_native
-
-
-def get_speckle_subobjects(attr, scale, name):
-    subobjects = []
-    for key in attr.keys():
-        if isinstance(attr[key], dict):
-            subtype = attr[key].get("type", None)
-            if subtype:
-                name = f"{name}.{key}"
-                subobject = convert_to_native(attr[key], name)
-
-                subobjects.append(subobject)
-                props = attr[key].get("properties", None)
-                if props:
-                    subobjects.extend(get_speckle_subobjects(props, scale, name))
-        elif hasattr(attr[key], "type"):
-            subtype = attr[key].type
-            if subtype:
-                name = "{}.{}".format(name, key)
-                subobject = convert_to_native(attr[key], name)
-
-                subobjects.append(subobject)
-                props = attr[key].get("properties", None)
-                if props:
-                    subobjects.extend(get_speckle_subobjects(props, scale, name))
-    return subobjects

bpy_speckle/convert/to_native.py

@@ -1,389 +0,0 @@
-import math
-from bpy_speckle.functions import get_scale_length, _report
-import mathutils
-import bpy, bmesh, bpy_types
-from specklepy.objects.other import *
-from specklepy.objects.geometry import *
-from .util import (
-    add_blender_material,
-    add_custom_properties,
-    add_vertices,
-    add_faces,
-    add_colors,
-    add_uv_coords,
-)
-
-SUPPORTED_CURVES = (Line, Polyline, Curve, Arc, Polycurve)
-
-CAN_CONVERT_TO_NATIVE = (
-    Mesh,
-    Brep,
-    *SUPPORTED_CURVES,
-    Transform,
-    BlockDefinition,
-    BlockInstance,
-)
-
-
-def can_convert_to_native(speckle_object):
-    if type(speckle_object) in CAN_CONVERT_TO_NATIVE:
-        return True
-    display = getattr(
-        speckle_object, "displayMesh", getattr(speckle_object, "displayValue", None)
-    )
-    if display:
-        return True
-
-    _report(f"Could not convert unsupported Speckle object: {speckle_object}")
-    return False
-
-
-def convert_to_native(speckle_object, name=None):
-    speckle_type = type(speckle_object)
-    speckle_name = (
-        name
-        or getattr(speckle_object, "name", None)
-        or speckle_object.speckle_type + f" -- {speckle_object.id}"
-    )
-    if speckle_type not in CAN_CONVERT_TO_NATIVE:
-        display = getattr(
-            speckle_object, "displayMesh", getattr(speckle_object, "displayValue", None)
-        )
-        if not display:
-            _report(f"Could not convert unsupported Speckle object: {speckle_object}")
-            return
-        # add parent type here so we can use it as a blender custom prop
-        # not making it hidden, so it will get added on send as i think it might be helpful? can reconsider
-        if isinstance(display, list):
-            for item in display:
-                item.parent_speckle_type = speckle_object.speckle_type
-                convert_to_native(item)
-        else:
-            display.parent_speckle_type = speckle_object.speckle_type
-            return convert_to_native(display, speckle_name)
-
-    units = getattr(speckle_object, "units", None)
-    if units:
-        scale = get_scale_length(units) / bpy.context.scene.unit_settings.scale_length
-
-    try:
-        if speckle_type is Mesh:
-            obj_data = mesh_to_native(speckle_object, name=speckle_name, scale=scale)
-        elif speckle_type is Brep:
-            obj_data = brep_to_native(speckle_object, name=speckle_name, scale=scale)
-        elif speckle_type in SUPPORTED_CURVES:
-            obj_data = icurve_to_native(speckle_object, name=speckle_name, scale=scale)
-        elif speckle_type is Transform:
-            obj_data = transform_to_native(speckle_object, scale=scale)
-        elif speckle_type is BlockDefinition:
-            obj_data = block_def_to_native(speckle_object, scale=scale)
-        elif speckle_type is BlockInstance:
-            obj_data = block_instance_to_native(speckle_object, scale=scale)
-        else:
-            _report(f"Unsupported type {speckle_type}")
-            return None
-    except Exception as ex:  # conversion error
-        _report(f"Error converting {speckle_object} \n{ex}")
-        return None
-
-    if speckle_name in bpy.data.objects.keys():
-        blender_object = bpy.data.objects[speckle_name]
-        blender_object.data = (
-            obj_data.data if isinstance(obj_data, bpy_types.Object) else obj_data
-        )
-        blender_object.matrix_world = (
-            blender_object.matrix_world
-            if speckle_type is BlockInstance
-            else mathutils.Matrix()
-        )
-        if hasattr(obj_data, "materials"):
-            blender_object.data.materials.clear()
-    else:
-        blender_object = (
-            obj_data
-            if isinstance(obj_data, bpy_types.Object)
-            else bpy.data.objects.new(speckle_name, obj_data)
-        )
-
-    blender_object.speckle.object_id = str(speckle_object.id)
-    blender_object.speckle.enabled = True
-    add_custom_properties(speckle_object, blender_object)
-    add_blender_material(speckle_object, blender_object)
-
-    return blender_object
-
-
-def brep_to_native(speckle_brep, name, scale=1.0):
-    display = getattr(
-        speckle_brep, "displayMesh", getattr(speckle_brep, "displayValue", None)
-    )
-    return mesh_to_native(display, name, scale) if display else None
-
-
-def mesh_to_native(speckle_mesh, name, scale=1.0):
-
-    if name in bpy.data.meshes.keys():
-        blender_mesh = bpy.data.meshes[name]
-    else:
-        blender_mesh = bpy.data.meshes.new(name=name)
-
-    bm = bmesh.new()
-
-    add_vertices(speckle_mesh, bm, scale)
-    add_faces(speckle_mesh, bm)
-    add_colors(speckle_mesh, bm)
-    add_uv_coords(speckle_mesh, bm)
-
-    bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
-    bm.to_mesh(blender_mesh)
-    bm.free()
-
-    return blender_mesh
-
-
-def line_to_native(speckle_curve, blender_curve, scale):
-    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,
-    )
-
-    if speckle_curve.end:
-
-        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, bcurve, scale):
-
-    # value = find_key_case_insensitive(scurve, "value")
-    value = scurve.value
-
-    if value:
-        N = len(value) // 3
-
-        polyline = bcurve.splines.new("POLY")
-
-        if hasattr(scurve, "closed"):
-            polyline.use_cyclic_u = scurve.closed
-
-        # if "closed" in scurve.keys():
-        #    polyline.use_cyclic_u = scurve["closed"]
-
-        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, bcurve, scale):
-
-    # points = find_key_case_insensitive(scurve, "points")
-    points = scurve.points
-
-    if points:
-        N = len(points) // 3
-
-        nurbs = bcurve.splines.new("NURBS")
-
-        if hasattr(scurve, "closed"):
-            nurbs.use_cyclic_u = scurve.closed != 0
-
-        nurbs.points.add(N - 1)
-        for i in range(N):
-            nurbs.points[i].co = (
-                float(points[i * 3]) * scale,
-                float(points[i * 3 + 1]) * scale,
-                float(points[i * 3 + 2]) * scale,
-                1,
-            )
-
-        if len(scurve.weights) == len(nurbs.points):
-            for i, w in enumerate(scurve.weights):
-                nurbs.points[i].weight = w
-
-        # TODO: anaylize curve knots to decide if use_endpoint_u or use_bezier_u should be enabled
-        # nurbs.use_endpoint_u = True
-        nurbs.order_u = scurve.degree + 1
-
-        return nurbs
-
-
-def arc_to_native(rcurve, bcurve, scale):
-    # TODO: improve Blender representation of arc
-
-    plane = rcurve.plane
-    if not plane:
-        return
-
-    normal = mathutils.Vector([plane.normal.x, plane.normal.y, plane.normal.z])
-
-    radius = rcurve.radius * scale
-    startAngle = rcurve.startAngle
-    endAngle = rcurve.endAngle
-
-    startQuat = mathutils.Quaternion(normal, startAngle)
-    endQuat = mathutils.Quaternion(normal, endAngle)
-
-    # Get start and end vectors, centre point, angles, etc.
-    r1 = mathutils.Vector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r1.rotate(startQuat)
-
-    r2 = mathutils.Vector([plane.xdir.x, plane.xdir.y, plane.xdir.z])
-    r2.rotate(endQuat)
-
-    c = mathutils.Vector([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 = mathutils.Quaternion(normal, step)
-    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, bcurve, scale):
-    """
-    Convert Polycurve object
-    """
-    segments = scurve.segments
-
-    curves = []
-
-    for seg in segments:
-        speckle_type = type(seg)
-
-        if speckle_type in SUPPORTED_CURVES:
-            curves.append(icurve_to_native_spline(seg, bcurve, scale=scale))
-        else:
-            _report(f"Unsupported curve type: {speckle_type}")
-
-    return curves
-
-
-def icurve_to_native_spline(speckle_curve, blender_curve, scale=1.0):
-    curve_type = type(speckle_curve)
-    if curve_type is Line:
-        return line_to_native(speckle_curve, blender_curve, scale)
-    if curve_type is Polyline:
-        return polyline_to_native(speckle_curve, blender_curve, scale)
-    if curve_type is Curve:
-        return nurbs_to_native(speckle_curve, blender_curve, scale)
-    if curve_type is Polycurve:
-        return polycurve_to_native(speckle_curve, blender_curve, scale)
-    if curve_type is Arc:
-        return arc_to_native(speckle_curve, blender_curve, scale)
-
-
-def icurve_to_native(speckle_curve, name=None, scale=1.0):
-    curve_type = type(speckle_curve)
-    if curve_type not in SUPPORTED_CURVES:
-        _report(f"Unsupported curve type: {curve_type}")
-        return None
-    name = name or f"{curve_type} -- {speckle_curve.id}"
-    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
-
-    icurve_to_native_spline(speckle_curve, blender_curve, scale)
-
-    return blender_curve
-
-
-def transform_to_native(transform: Transform, scale=1.0):
-    mat = mathutils.Matrix(
-        [
-            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 block_def_to_native(definition: BlockDefinition, scale=1.0):
-    native_def = bpy.data.collections.get(definition.name)
-    if native_def:
-        return native_def
-
-    native_def = bpy.data.collections.new(definition.name)
-    native_def["applicationId"] = definition.applicationId
-    for geo in definition.geometry:
-        b_obj = convert_to_native(geo)
-        if b_obj:
-            native_def.objects.link(
-                b_obj
-                if isinstance(b_obj, bpy_types.Object)
-                else bpy.data.objects.new(b_obj.name, b_obj)
-            )
-
-    return native_def
-
-
-def block_instance_to_native(instance: BlockInstance, scale=1.0):
-    """
-    Convert BlockInstance to native
-    """
-    name = f"{getattr(instance, 'name', None) or instance.blockDefinition.name} -- {instance.id}"
-    native_def = block_def_to_native(instance.blockDefinition, scale)
-
-    native_instance = bpy.data.objects.new(name, None)
-    # hide the instance axes so they don't clutter the viewport
-    native_instance.empty_display_size = 0
-    native_instance.instance_collection = native_def
-    native_instance.instance_type = "COLLECTION"
-    native_instance.matrix_world = transform_to_native(instance.transform, scale)
-    return native_instance

bpy_speckle/convert/to_speckle.py

@@ -1,312 +0,0 @@
-import bpy
-from specklepy.objects.geometry import Mesh, Curve, Interval, Box, Point, Polyline
-from specklepy.objects.other import *
-from bpy_speckle.functions import _report
-from bpy_speckle.convert.util import (
-    get_blender_custom_properties,
-    make_knots,
-    to_argb_int,
-)
-
-UNITS = "m"
-
-CAN_CONVERT_TO_SPECKLE = ("MESH", "CURVE", "EMPTY")
-
-
-def convert_to_speckle(blender_object, scale, desgraph=None):
-    blender_type = blender_object.type
-    if blender_type not in CAN_CONVERT_TO_SPECKLE:
-        return
-
-    speckle_objects = []
-    speckle_material = material_to_speckle(blender_object)
-    if desgraph:
-        blender_object = blender_object.evaluated_get(desgraph)
-    converted = None
-    if blender_type == "MESH":
-        converted = mesh_to_speckle(blender_object, blender_object.data, scale)
-    elif blender_type == "CURVE":
-        converted = icurve_to_speckle(blender_object, blender_object.data, scale)
-    elif blender_type == "EMPTY":
-        converted = empty_to_speckle(blender_object, scale)
-    if not converted:
-        return None
-
-    if isinstance(converted, list):
-        speckle_objects.extend([c for c in converted if c != None])
-    else:
-        speckle_objects.append(converted)
-    for so in speckle_objects:
-        so.properties = get_blender_custom_properties(blender_object)
-        so.applicationId = so.properties.pop("applicationId", None)
-
-        if speckle_material:
-            so["renderMaterial"] = speckle_material
-
-        # Set object transform
-        if blender_type != "EMPTY":
-            so.properties["transform"] = transform_to_speckle(
-                blender_object.matrix_world
-            )
-
-    return speckle_objects
-
-
-def mesh_to_speckle(blender_object, data, scale=1.0):
-    if data.loop_triangles is None or len(data.loop_triangles) < 1:
-        data.calc_loop_triangles()
-
-    mat = blender_object.matrix_world
-
-    verts = [tuple(mat @ x.co * scale) for x in data.vertices]
-
-    faces = [p.vertices for p in data.polygons]
-    unit_system = bpy.context.scene.unit_settings.system
-
-    sm = Mesh(
-        name=blender_object.name,
-        vertices=list(sum(verts, ())),
-        faces=[],
-        colors=[],
-        textureCoordinates=[],
-        units="m" if unit_system == "METRIC" else "ft",
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-    if data.uv_layers.active:
-        for vt in data.uv_layers.active.data:
-            sm.textureCoordinates.extend([vt.uv.x, vt.uv.y])
-
-    for f in faces:
-        n = len(f)
-        if n == 3:
-            sm.faces.append(0)
-        elif n == 4:
-            sm.faces.append(1)
-        else:
-            sm.faces.append(n)
-        sm.faces.extend(f)
-
-    return [sm]
-
-
-def bezier_to_speckle(matrix, spline, scale, name=None):
-    degree = 3
-    closed = spline.use_cyclic_u
-
-    points = []
-    for i, bp in enumerate(spline.bezier_points):
-        if i > 0:
-            points.append(tuple(matrix @ bp.handle_left * scale))
-        points.append(tuple(matrix @ bp.co * scale))
-        if i < len(spline.bezier_points) - 1:
-            points.append(tuple(matrix @ bp.handle_right * scale))
-
-    if closed:
-        points.append(tuple(matrix @ spline.bezier_points[-1].handle_right * scale))
-        points.append(tuple(matrix @ spline.bezier_points[0].handle_left * scale))
-        points.append(tuple(matrix @ spline.bezier_points[0].co * scale))
-
-    num_points = len(points)
-
-    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=spline.use_cyclic_u,
-        points=list(sum(points, ())),  # magic (flatten list of tuples)
-        weights=[1] * num_points,
-        knots=knots,
-        rational=False,
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=UNITS,
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-
-def nurbs_to_speckle(matrix, spline, scale, name=None):
-    knots = make_knots(spline)
-    points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
-    degree = spline.order_u - 1
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-
-    return Curve(
-        name=name,
-        degree=degree,
-        closed=spline.use_cyclic_u,
-        periodic=spline.use_cyclic_u,
-        points=list(sum(points, ())),  # magic (flatten list of tuples)
-        weights=[pt.weight for pt in spline.points],
-        knots=knots,
-        rational=False,
-        area=0,
-        volume=0,
-        length=length,
-        domain=domain,
-        units=UNITS,
-        bbox=Box(area=0.0, volume=0.0),
-    )
-
-
-def poly_to_speckle(matrix, spline, scale, name=None):
-    points = [tuple(matrix @ pt.co.xyz * scale) for pt in spline.points]
-
-    length = spline.calc_length()
-    domain = Interval(start=0, end=length, totalChildrenCount=0)
-    return Polyline(
-        name=name,
-        closed=spline.use_cyclic_u,
-        value=list(sum(points, ())),  # magic (flatten list of tuples)
-        length=length,
-        domain=domain,
-        bbox=Box(area=0.0, volume=0.0),
-        area=0,
-        units=UNITS,
-    )
-
-
-def icurve_to_speckle(blender_object, data, scale=1.0):
-    UNITS = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-
-    if blender_object.type != "CURVE":
-        return None
-
-    blender_object = blender_object.evaluated_get(bpy.context.view_layer.depsgraph)
-
-    mat = blender_object.matrix_world
-
-    curves = []
-
-    if data.bevel_mode == "OBJECT" and data.bevel_object != None:
-        mesh = mesh_to_speckle(blender_object, blender_object.to_mesh(), scale)
-        curves.extend(mesh)
-
-    for spline in data.splines:
-        if spline.type == "BEZIER":
-            curves.append(bezier_to_speckle(mat, spline, scale, blender_object.name))
-
-        elif spline.type == "NURBS":
-            curves.append(nurbs_to_speckle(mat, spline, scale, blender_object.name))
-
-        elif spline.type == "POLY":
-            curves.append(poly_to_speckle(mat, spline, scale, blender_object.name))
-
-    return curves
-
-
-def ngons_to_speckle_polylines(blender_object, data, scale=1.0):
-    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 * scale)
-
-        domain = Interval(start=0, end=1)
-        poly = Polyline(
-            name="{}_{}".format(blender_object.name, i),
-            closed=True,
-            value=value,  # magic (flatten list of tuples)
-            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_object) -> RenderMaterial:
-    """Create and return a render material from a blender object"""
-    if not getattr(blender_object.data, "materials", None):
-        return
-
-    blender_mat = blender_object.data.materials[0]
-    speckle_mat = RenderMaterial()
-    speckle_mat.name = blender_mat.name
-
-    if blender_mat.use_nodes is True:
-        inputs = blender_mat.node_tree.nodes["Principled BSDF"].inputs
-        speckle_mat.diffuse = to_argb_int(inputs["Base Color"].default_value)
-        speckle_mat.emissive = to_argb_int(inputs["Emission"].default_value)
-        speckle_mat.roughness = inputs["Roughness"].default_value
-        speckle_mat.metalness = inputs["Metallic"].default_value
-        speckle_mat.opacity = inputs["Alpha"].default_value
-
-    else:
-        speckle_mat.diffuse = to_argb_int(blender_mat.diffuse_color)
-        speckle_mat.metalness = blender_mat.metallic
-        speckle_mat.roughness = blender_mat.roughness
-
-    return speckle_mat
-
-
-def transform_to_speckle(blender_transform, scale=1.0):
-    units = "m" if bpy.context.scene.unit_settings.system == "METRIC" else "ft"
-    value = [y for x in blender_transform for y in x]
-    # scale the translation
-    for i in (3, 7, 11):
-        value[i] *= scale
-
-    return Transform(value=value, units=units)
-
-
-def block_def_to_speckle(blender_definition, scale=1.0):
-    geometry = []
-    for geo in blender_definition.objects:
-        geometry.extend(convert_to_speckle(geo, scale))
-    block_def = BlockDefinition(
-        units=UNITS,
-        name=blender_definition.name,
-        geometry=geometry,
-        basePoint=Point(units=UNITS),
-    )
-    blender_props = get_blender_custom_properties(blender_definition)
-    block_def.applicationId = blender_props.pop("applicationId", None)
-    return block_def
-
-
-def block_instance_to_speckle(blender_instance, scale=1.0):
-    return BlockInstance(
-        blockDefinition=block_def_to_speckle(
-            blender_instance.instance_collection, scale
-        ),
-        transform=transform_to_speckle(blender_instance.matrix_world),
-        name=blender_instance.name,
-        units=UNITS,
-    )
-
-
-def empty_to_speckle(blender_object, scale=1.0):
-    # probably an instance collection (block) so let's try it
-    try:
-        geo = blender_object.instance_collection.objects.items()
-        return block_instance_to_speckle(blender_object, scale)
-    except AttributeError as err:
-        _report(
-            f"No instance collection found in empty. Skipping object {blender_object.name}"
-        )
-        return None

bpy_speckle/convert/util.py

@@ -1,290 +0,0 @@
-import base64
-from typing import Tuple
-import bpy, struct, idprop
-
-from specklepy.serialization.base_object_serializer import BaseObjectSerializer
-from bpy_speckle.functions import _report
-
-
-def to_rgba(argb_int: int) -> Tuple[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(diffuse_colour) -> int:
-    """Converts an RGBA array to an ARGB integer"""
-    diffuse_colour = diffuse_colour[-1:] + diffuse_colour[:3]
-    diffuse_colour = [int(val * 255) for val in diffuse_colour]
-
-    return int.from_bytes(diffuse_colour, byteorder="big", signed=True)
-
-
-def add_custom_properties(speckle_object, blender_object):
-    if blender_object is None:
-        return
-
-    serializer = BaseObjectSerializer()
-    blender_object["_speckle_type"] = type(speckle_object).__name__
-
-    app_id = getattr(speckle_object, "applicationId", None)
-    if app_id:
-        blender_object["applicationId"] = speckle_object.applicationId
-
-    for key in speckle_object.get_dynamic_member_names():
-        if isinstance(speckle_object[key], (int, str, float)):
-            blender_object[key] = speckle_object[key]
-        elif isinstance(speckle_object[key], (dict, list)):
-            blender_object[key] = serializer.traverse_value(speckle_object[key])
-
-
-def add_blender_material(speckle_object, blender_object) -> None:
-    """Add material to a blender object if the corresponding speckle object has a render material"""
-    if blender_object.data is None:
-        return
-
-    speckle_mat = getattr(
-        speckle_object,
-        "renderMaterial",
-        getattr(speckle_object, "@renderMaterial", None),
-    )
-    if not speckle_mat:
-        return
-
-    mat_name = getattr(speckle_mat, "name", None) or speckle_mat.__dict__.get("@name")
-    if not mat_name:
-        mat_name = speckle_mat.applicationId or speckle_mat.id or speckle_mat.get_id()
-
-    blender_mat = bpy.data.materials.get(mat_name)
-    if not blender_mat:
-        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)
-        inputs["Emission"].default_value = to_rgba(speckle_mat.emissive)
-        inputs["Roughness"].default_value = speckle_mat.roughness
-        inputs["Metallic"].default_value = speckle_mat.metalness
-        inputs["Alpha"].default_value = speckle_mat.opacity
-
-    if speckle_mat.opacity < 1:
-        blender_mat.blend_method = "BLEND"
-
-    blender_object.data.materials.append(blender_mat)
-
-
-def add_vertices(speckle_mesh, blender_mesh, 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,
-                )
-            )
-
-    blender_mesh.verts.ensure_lookup_table()
-
-
-def add_faces(speckle_mesh, blender_mesh, smooth=False):
-    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[int(x)] for x in sfaces[i : i + n]]
-                )
-                f.smooth = smooth
-            except Exception as e:
-                _report(f"Failed to create face for mesh {speckle_mesh.id} \n{e}")
-            i += n
-
-        blender_mesh.faces.ensure_lookup_table()
-        blender_mesh.verts.index_update()
-
-
-def add_colors(speckle_mesh, blender_mesh):
-
-    scolors = speckle_mesh.colors
-
-    if scolors:
-        colors = []
-        if len(scolors) > 0:
-
-            for i in range(len(scolors)):
-                col = int(scolors[i])
-                (a, r, g, b) = [
-                    int(x) for x in struct.unpack("!BBBB", struct.pack("!i", col))
-                ]
-                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 add_uv_coords(speckle_mesh, blender_mesh):
-    if not hasattr(speckle_mesh, "properties"):
-        return
-
-    sprops = speckle_mesh.properties
-    if sprops:
-        texKey = ""
-        if "texture_coordinates" in sprops.keys():
-            texKey = "texture_coordinates"
-        elif "TextureCoordinates" in sprops.keys():
-            texKey = "TextureCoordinates"
-
-        if texKey != "":
-
-            try:
-                decoded = base64.b64decode(sprops[texKey]).decode("utf-8")
-                s_uvs = decoded.split()
-                uv = []
-
-                if len(s_uvs) // 2 == len(blender_mesh.verts):
-                    for i in range(0, len(s_uvs), 2):
-                        uv.append((float(s_uvs[i]), float(s_uvs[i + 1])))
-                else:
-                    _report(
-                        f"Failed to match UV coordinates to vert data. Blender mesh verts: {len(blender_mesh.verts)}, Speckle UVs * 2: {len(s_uvs) * 2}"
-                    )
-
-                # Make UVs
-                uv_layer = blender_mesh.loops.layers.uv.verify()
-
-                for f in blender_mesh.faces:
-                    for l in f.loops:
-                        luv = l[uv_layer]
-                        luv.uv = uv[l.vert.index]
-            except:
-                _report("Failed to decode texture coordinates.")
-                raise
-
-            del speckle_mesh.properties[texKey]
-
-
-ignored_keys = (
-    "speckle",
-    "_speckle_type",
-    "_speckle_name",
-    "_speckle_transform",
-    "_RNA_UI",
-    "transform",
-    "_units",
-    "_chunkable",
-)
-
-
-def get_blender_custom_properties(obj, max_depth=1000):
-    if max_depth < 0:
-        return obj
-
-    if hasattr(obj, "keys"):
-        return {
-            key: get_blender_custom_properties(obj[key], max_depth - 1)
-            for key in obj.keys()
-            if key not in ignored_keys and not key.startswith("_")
-        }
-
-    elif isinstance(obj, (list, tuple, idprop.types.IDPropertyArray)):
-        return [get_blender_custom_properties(o, max_depth - 1) for o in obj]
-    else:
-        return obj
-
-
-"""
-Python implementation of Blender's NURBS curve generation for to Speckle conversion
-from: https://blender.stackexchange.com/a/34276
-"""
-
-
-def macro_knotsu(nu):
-    return nu.order_u + nu.point_count_u + (nu.order_u - 1 if nu.use_cyclic_u else 0)
-
-
-def macro_segmentsu(nu):
-    return nu.point_count_u if nu.use_cyclic_u else nu.point_count_u - 1
-
-
-def make_knots(nu):
-    knots = [0.0] * (4 + macro_knotsu(nu))
-    flag = nu.use_endpoint_u + (nu.use_bezier_u << 1)
-    if nu.use_cyclic_u:
-        calc_knots(knots, nu.point_count_u, nu.order_u, 0)
-        makecyclicknots(knots, nu.point_count_u, nu.order_u)
-    else:
-        calc_knots(knots, nu.point_count_u, nu.order_u, flag)
-    return knots
-
-
-def calc_knots(knots, point_count, order, flag):
-    pts_order = point_count + order
-    if flag == 1:
-        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:
-        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(pts_order):
-            knots[a] = a
-
-
-def makecyclicknots(knots, point_count, order):
-    order2 = order - 1
-
-    if order > 2:
-        b = point_count + order2
-        for a in range(1, order2):
-            if knots[b] != knots[b - a]:
-                break
-
-            if a == order2:
-                knots[point_count + order - 2] += 1.0
-
-    b = order
-    c = point_count + order + order2
-    for a in range(point_count + order2, c):
-        knots[a] = knots[a - 1] + (knots[b] - knots[b - 1])
-        b -= 1

bpy_speckle/converter/__init__.py

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

bpy_speckle/converter/utils.py

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

@@ -1,72 +0,0 @@
-from bpy_speckle.clients import speckle_clients
-
-"""
-Speckle functions
-"""
-
-unit_scale = {
-    "meters": 1.0,
-    "centimeters": 0.01,
-    "millimeters": 0.001,
-    "inches": 0.0254,
-    "feet": 0.3048,
-    "kilometers": 1000.0,
-    "mm": 0.001,
-    "cm": 0.01,
-    "m": 1.0,
-    "km": 1000.0,
-    "in": 0.0254,
-    "ft": 0.3048,
-    "yd": 0.9144,
-    "mi": 1609.340,
-}
-
-"""
-Utility functions
-"""
-
-
-def _report(msg):
-    """
-    Function for printing messages to the console
-    """
-    print("SpeckleBlender: {}".format(msg))
-
-
-def get_scale_length(units):
-    if units.lower() in unit_scale.keys():
-        return unit_scale[units]
-    _report("Units <{}> are not supported.".format(units))
-    return 1.0
-
-
-"""
-Client, user, and stream functions
-"""
-
-
-def _check_speckle_client_user_stream(scene):
-    """
-    Verify that there is a valid user and stream
-    """
-    speckle = scene.speckle
-
-    user = (
-        speckle.users[int(speckle.active_user)]
-        if len(speckle.users) > int(speckle.active_user)
-        else None
-    )
-
-    if user is None:
-        print("No users loaded.")
-
-    stream = (
-        user.streams[user.active_stream]
-        if len(user.streams) > user.active_stream
-        else None
-    )
-
-    if stream is None:
-        print("Account contains no streams.")
-
-    return (user, stream)

bpy_speckle/install_dependencies.py

@@ -1,104 +0,0 @@
-import os, sys, bpy
-import ctypes, sys
-
-import os, sys
-
-
-def modules_path():
-    # set up addons/modules under the user
-    # script path. Here we'll install the
-    # dependencies
-    modulespath = os.path.normpath(
-        os.path.join(bpy.utils.script_path_user(), "addons", "modules")
-    )
-    if not os.path.exists(modulespath):
-        os.makedirs(modulespath)
-
-    # set user modules path at beginning of paths for earlier hit
-    if sys.path[1] != modulespath:
-        sys.path.insert(1, modulespath)
-
-    return modulespath
-
-
-def install_dependencies():
-    import sys
-    import os
-
-    try:
-        try:
-            import pip
-        except:
-            print("Installing pip... "),
-            from subprocess import run as sprun
-
-            res = sprun([bpy.app.binary_path_python, "-m", "ensurepip"])
-
-            if res.returncode == 0:
-                import pip
-            else:
-                raise Exception("Failed to install pip.")
-
-        modulespath = modules_path()
-
-        if not os.path.exists(modulespath):
-            os.makedirs(modulespath)
-
-        print("Installing speckle to {}... ".format(modulespath)),
-        from subprocess import run as sprun
-
-        res = sprun(
-            [
-                bpy.app.binary_path_python,
-                "-m",
-                "pip",
-                "install",
-                "-q",
-                "-t",
-                "{}".format(modulespath),
-                "--no-deps",
-                "pydantic",
-            ]
-        )
-        res = sprun(
-            [
-                bpy.app.binary_path_python,
-                "-m",
-                "pip",
-                "install",
-                "-q",
-                "-t",
-                "{}".format(modulespath),
-                "specklepy",
-            ]
-        )
-
-    except:
-        raise Exception(
-            "Failed to install dependencies. Please make sure you have pip installed."
-        )
-
-
-if __name__ == "__main__":
-    try:
-        import specklepy
-    except:
-        print("Failed to load speckle.")
-        from sys import platform
-
-        if platform == "win32":
-            if ctypes.windll.shell32.IsUserAnAdmin():
-                install_dependencies()
-                import specklepy
-            else:
-                ctypes.windll.shell32.ShellExecuteW(
-                    None, "runas", sys.executable, __file__, None, 1
-                )
-
-        else:
-            print(
-                "Platform {} cannot automatically install dependencies.".format(
-                    platform
-                )
-            )
-            raise

bpy_speckle/installer.py

@@ -0,0 +1,246 @@
+"""
+Provides uniform and consistent path helpers for `specklepy`
+"""
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+from importlib import import_module, invalidate_caches
+
+_user_data_env_var = "SPECKLE_USERDATA_PATH"
+
+
+def _path() -> Optional[Path]:
+    """Read the user data path override setting."""
+    path_override = os.environ.get(_user_data_env_var)
+    if path_override:
+        return Path(path_override)
+    return None
+
+
+_application_name = "Speckle"
+
+
+def override_application_name(application_name: str) -> None:
+    """Override the global Speckle application name."""
+    global _application_name
+    _application_name = application_name
+
+
+def override_application_data_path(path: Optional[str]) -> None:
+    """
+    Override the global Speckle application data path.
+
+    If the value of path is `None` the environment variable gets deleted.
+    """
+    if path:
+        os.environ[_user_data_env_var] = path
+    else:
+        os.environ.pop(_user_data_env_var, None)
+
+
+def _ensure_folder_exists(base_path: Path, folder_name: str) -> Path:
+    path = base_path.joinpath(folder_name)
+    path.mkdir(exist_ok=True, parents=True)
+    return path
+
+
+def user_application_data_path() -> Path:
+    """Get the platform specific user configuration folder path"""
+    path_override = _path()
+    if path_override:
+        return path_override
+
+    try:
+        if sys.platform.startswith("win"):
+            app_data_path = os.getenv("APPDATA")
+            if not app_data_path:
+                raise Exception(
+                    "Cannot get appdata path from environment."
+                )
+            return Path(app_data_path)
+        else:
+            # try getting the standard XDG_DATA_HOME value
+            # as that is used as an override
+            app_data_path = os.getenv("XDG_DATA_HOME")
+            if app_data_path:
+                return Path(app_data_path)
+            else:
+                return _ensure_folder_exists(Path.home(), ".config")
+    except Exception as ex:
+        raise Exception(
+            "Failed to initialize user application data path.", ex
+        )
+
+
+def user_speckle_folder_path() -> Path:
+    """Get the folder where the user's Speckle data should be stored."""
+    return _ensure_folder_exists(user_application_data_path(), _application_name)
+
+
+def user_speckle_connector_installation_path(host_application: str) -> Path:
+    """
+    Gets a connector specific installation folder.
+
+    In this folder we can put our connector installation and all python packages.
+    """
+    return _ensure_folder_exists(
+        _ensure_folder_exists(user_speckle_folder_path(), "connector_installations"),
+        host_application,
+    )
+
+
+
+
+
+
+print("Starting module dependency installation")
+print(sys.executable)
+
+PYTHON_PATH = sys.executable
+
+
+
+def connector_installation_path(host_application: str) -> Path:
+    connector_installation_path = user_speckle_connector_installation_path(host_application)
+    connector_installation_path.mkdir(exist_ok=True, parents=True)
+
+    # set user modules path at beginning of paths for earlier hit
+    if sys.path[0] != connector_installation_path:
+        sys.path.insert(0, str(connector_installation_path))
+
+    print(f"Using connector installation path {connector_installation_path}")
+    return connector_installation_path
+
+
+
+def is_pip_available() -> bool:
+    try:
+        import_module("pip")  # noqa F401
+        return True
+    except ImportError:
+        return False
+
+
+def ensure_pip() -> None:
+    print("Installing pip... ")
+
+    from subprocess import run
+
+    completed_process = run([PYTHON_PATH, "-m", "ensurepip"])
+
+    if completed_process.returncode == 0:
+        print("Successfully installed pip")
+    else:
+        raise Exception(f"Failed to install pip, got {completed_process.returncode} return code")
+
+
+def is_uv_available() -> bool:
+    try:
+        import_module("uv")  # noqa F401
+        return True
+    except ImportError:
+        return False
+
+
+def ensure_uv() -> None:
+    print("Installing uv... ")
+    from subprocess import run
+    completed_process = run([PYTHON_PATH, "-m", "pip", "install", "uv"])
+    if completed_process.returncode == 0:
+        print("Successfully installed uv")
+    else:
+        raise Exception(f"Failed to install uv, got {completed_process.returncode} return code")
+
+
+def get_requirements_path() -> Path:
+    # we assume that a requirements.txt exists next to the __init__.py file
+    path = Path(Path(__file__).parent, "requirements.txt")
+    return path
+
+
+def install_requirements(host_application: str) -> None:
+    # set up addons/modules under the user
+    # script path. Here we'll install the
+    # dependencies
+    path = connector_installation_path(host_application)
+
+    from subprocess import run
+
+    def debugger_is_active() -> bool:
+        """Return if the debugger is currently active"""
+        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
+
+    print(f"Installing Speckle dependencies to {path}")
+    completed_process = run(
+        [
+            PYTHON_PATH,
+            "-m",
+            "uv",
+            "pip",
+            "install",
+            "--system",
+            "--target",
+            str(path),
+            "-r",
+            str(requirements_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    if completed_process.returncode != 0:
+        m = f"Failed to install dependencies through uv, got {completed_process.returncode} return code"
+        print(m)
+        raise Exception(m)
+    
+    print("Successfully installed dependencies")
+
+    if not is_debug:
+        requirements_path.unlink()
+
+
+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)
+
+
+def _import_dependencies() -> None:
+    import_module("specklepy")
+    # the code above doesn't work for now, it fails on importing graphql-core
+    # despite that, the connector seams to be working as expected
+    # But it would be nice to make this solution work
+    # it would ensure that all dependencies are fully loaded  
+    # requirements = get_requirements_path().read_text()
+    # reqs = [
+    #     req.split(" ; ")[0].split("==")[0].split("[")[0].replace("-", "_")
+    #     for req in requirements.split("\n")
+    #     if req and not req.startswith(" ")
+    # ]
+    # for req in reqs:
+    #     print(req)
+    #     import_module("specklepy")
+
+def ensure_dependencies(host_application: str) -> None:
+    try:
+        install_dependencies(host_application)
+        invalidate_caches()
+        _import_dependencies()
+        print("Successfully found dependencies")
+    except ImportError:
+        raise Exception(f"Cannot automatically ensure Speckle dependencies. Please try restarting the host application {host_application}!")
+
+

bpy_speckle/operators/__init__.py

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

bpy_speckle/operators/commit.py

@@ -1,63 +0,0 @@
-"""
-Commit operators
-"""
-import bpy
-from bpy.props import BoolProperty
-from bpy_speckle.functions import _check_speckle_client_user_stream
-from bpy_speckle.clients import speckle_clients
-
-
-class DeleteCommit(bpy.types.Operator):
-    """
-    Delete stream
-    """
-
-    bl_idname = "speckle.delete_commit"
-    bl_label = "Delete commit"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Delete active commit permanently"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        default=False,
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        if not self.are_you_sure:
-            return {"CANCELLED"}
-
-        self.are_you_sure = False
-
-        speckle = context.scene.speckle
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, stream = check
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        branch = stream.branches[int(stream.branch)]
-        if len(branch.commits) < 1:
-            return {"CANCELLED"}
-        commit = branch.commits[int(branch.commit)]
-
-        deleted = client.commit.delete(stream_id=stream.id, commit_id=commit.id)
-
-        return {"FINISHED"}

bpy_speckle/operators/misc.py

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

bpy_speckle/operators/object.py

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

bpy_speckle/operators/streams.py

@@ -1,812 +0,0 @@
-"""
-Stream operators
-"""
-from itertools import chain
-from typing import Dict
-import bpy
-from specklepy.api.models import Commit
-import webbrowser
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-)
-from bpy_speckle.convert.to_native import can_convert_to_native, convert_to_native
-from bpy_speckle.convert.to_speckle import (
-    convert_to_speckle,
-    ngons_to_speckle_polylines,
-)
-from bpy_speckle.functions import (
-    _check_speckle_client_user_stream,
-    get_scale_length,
-    _report,
-)
-from bpy_speckle.convert import get_speckle_subobjects
-from bpy_speckle.clients import speckle_clients
-from bpy_speckle.operators.users import add_user_stream
-
-from specklepy.api import operations
-from specklepy.api.credentials import StreamWrapper
-from specklepy.api.resources.stream import Stream
-from specklepy.transports.server import ServerTransport
-from specklepy.objects.geometry import *
-from specklepy.logging.exceptions import SpeckleException
-
-
-def get_objects_collections(base) -> Dict:
-    """Create collections based on the dynamic members on a root commit object"""
-    collections = {}
-    for name in base.get_dynamic_member_names():
-        value = base[name]
-        if isinstance(value, list):
-            col = create_collection(name)
-            collections[name] = get_objects_nested_lists(value, col)
-        if isinstance(value, Base):
-            col = create_collection(name)
-            collections[name] = get_objects_collections_recursive(value, col)
-
-    return collections
-
-
-def get_objects_nested_lists(items, parent_col=None) -> List:
-    """For handling the weird nested lists that come from Grasshopper"""
-    objects = []
-
-    if isinstance(items[0], list):
-        items = list(chain.from_iterable(items))
-        objects.extend(get_objects_nested_lists(items, parent_col))
-    else:
-        objects = [
-            get_objects_collections_recursive(item, parent_col)
-            for item in items
-            if isinstance(item, Base)
-        ]
-
-    return objects
-
-
-def get_objects_collections_recursive(base, parent_col=None) -> List:
-    """Recursively create collections based on the dynamic members on nested `Base` objects within the root commit object"""
-    # if it's a convertable (registered) class and not just a plain `Base`, return the object itself
-    if can_convert_to_native(base):
-        return [base]
-
-    # if it's an unknown type, try to drill further down to find convertable objects
-    objects = []
-
-    for name in base.get_dynamic_member_names():
-        value = base[name]
-        if isinstance(value, list):
-            for item in value:
-                if isinstance(item, Base):
-                    objects.append(item)
-        if isinstance(value, Base):
-            col = parent_col.children.get(name)
-            if not col:
-                col = create_collection(name)
-                try:
-                    parent_col.children.link(col)
-                except:
-                    _report(
-                        f"Problem linking collection {col.name} to parent {parent_col.name}; skipping"
-                    )
-            objects.append({name: get_objects_collections_recursive(value, col)})
-
-    return objects
-
-
-def bases_to_native(context, collections, scale, stream_id, func=None):
-    for col_name, objects in collections.items():
-        col = bpy.data.collections[col_name]
-        existing = get_existing_collection_objs(col)
-        if isinstance(objects, dict):
-            bases_to_native(context, objects, scale, stream_id)
-        elif isinstance(objects, list):
-            for obj in objects:
-                if isinstance(obj, dict):
-                    bases_to_native(context, obj, scale, stream_id, func)
-                elif isinstance(obj, list):
-                    for item in obj:
-                        if isinstance(item, dict):
-                            bases_to_native(context, item, scale, stream_id, func)
-                        elif isinstance(item, Base):
-                            base_to_native(
-                                context, item, scale, stream_id, col, existing, func
-                            )
-                elif isinstance(obj, Base):
-                    base_to_native(context, obj, scale, stream_id, col, existing, func)
-
-                else:
-                    _report(
-                        f"Something went wrong when receiving collection: {col_name}"
-                    )
-
-            bpy.context.view_layer.update()
-
-            if context.area:
-                context.area.tag_redraw()
-
-
-def base_to_native(context, base, scale, stream_id, col, existing, func=None):
-    new_objects = [convert_to_native(base)]
-
-    if hasattr(base, "properties") and base.properties is not None:
-        new_objects.extend(get_speckle_subobjects(base.properties, scale, base.id))
-    elif isinstance(base, dict) and "properties" in base.keys():
-        new_objects.extend(
-            get_speckle_subobjects(base["properties"], scale, base["id"])
-        )
-
-    """
-    Set object Speckle settings
-    """
-    for new_object in new_objects:
-        if new_object is None:
-            continue
-
-        """
-        Run injected function
-        """
-        if func:
-            new_object = func(context.scene, new_object)
-
-        if (
-            new_object is None
-        ):  # Make sure that the injected function returned an object
-            new_obj = new_object
-            _report("Script '{}' returned None.".format(func.__module__))
-            continue
-
-        new_object.speckle.stream_id = stream_id
-        new_object.speckle.send_or_receive = "receive"
-
-        if new_object.speckle.object_id in existing.keys():
-            name = existing[new_object.speckle.object_id].name
-            existing[new_object.speckle.object_id].name = name + "__deleted"
-            new_object.name = name
-            col.objects.unlink(existing[new_object.speckle.object_id])
-
-        if new_object.name not in col.objects:
-            col.objects.link(new_object)
-
-
-def create_collection(name, clear_collection=True):
-    if name in bpy.data.collections:
-        col = bpy.data.collections[name]
-        if clear_collection:
-            for obj in col.objects:
-                col.objects.unlink(obj)
-    else:
-        col = bpy.data.collections.new(name)
-
-    return col
-
-
-def create_child_collections(parent_col, children_names):
-    for name in children_names:
-        col = create_collection(name)
-        parent_col.children.link(col)
-
-
-def get_existing_collection_objs(col):
-    return {
-        obj.speckle.object_id: obj for obj in col.objects if obj.speckle.object_id != ""
-    }
-
-
-def get_collection_parents(collection, names):
-    for parent in bpy.data.collections:
-        if collection.name in parent.children.keys():
-            # TODO: this should be rethought to make it clear when this is an IFC delim so we know to replace it
-            # with `/` again on receive
-            names.append(parent.name.replace("/", "::").replace(".", "::"))
-            get_collection_parents(parent, names)
-
-
-def get_collection_hierarchy(collection):
-    if not collection:
-        return []
-    names = [collection.name.replace("/", "::").replace(".", "::")]
-    get_collection_parents(collection, names)
-
-    return names
-
-
-def create_nested_hierarchy(base, hierarchy, objects):
-    child = base
-
-    while hierarchy:
-        name = hierarchy.pop()
-        if not hasattr(child, name):
-            child[name] = Base()
-            child.add_detachable_attrs({name})
-        child = child[name]
-
-    # TODO: what do we call this attribute?
-    if not hasattr(child, "@objects"):
-        child["@objects"] = []
-    child["@objects"].extend(objects)
-
-    return base
-
-
-class ReceiveStreamObjects(bpy.types.Operator):
-    """
-    Receive stream objects
-    """
-
-    bl_idname = "speckle.receive_stream_objects"
-    bl_label = "Download Stream Objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Receive objects from active stream"
-
-    def execute(self, context):
-        bpy.context.view_layer.objects.active = None
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, bstream = check
-
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        stream = client.stream.get(id=bstream.id)
-        if stream.branches.totalCount < 1:
-            return {"CANCELLED"}
-
-        if not stream.branches:
-            return {"CANCELLED"}
-
-        branch = stream.branches.items[int(bstream.branch)]
-
-        bbranch = bstream.branches[int(bstream.branch)]
-
-        if branch.commits.totalCount < 1:
-            _report("No commits found. Probably an empty stream.")
-            return {"CANCELLED"}
-
-        commit = branch.commits.items[int(bbranch.commit)]
-
-        transport = ServerTransport(stream.id, client)
-        stream_data = operations.receive(commit.referencedObject, transport)
-        client.commit.received(
-            bstream.id,
-            commit.id,
-            source_application="blender",
-            message="received commit from Speckle Blender",
-        )
-
-        """
-        Create or get Collection for stream objects
-        """
-        collections = get_objects_collections(stream_data)
-
-        if not collections:
-            return {"CANCELLED"}
-
-        name = "{} [ {} @ {} ]".format(stream.name, branch.name, commit.id)
-        col = create_collection(name)
-        col.speckle.stream_id = stream.id
-        col.speckle.name = stream.name
-        col.speckle.units = stream_data.units
-        if col.name not in bpy.context.scene.collection.children:
-            bpy.context.scene.collection.children.link(col)
-
-        for child_col in collections.keys():
-            try:
-                col.children.link(bpy.data.collections[child_col])
-            except:
-                pass
-        """
-        Set conversion scale from stream units
-        """
-        scale = (
-            get_scale_length(stream_data.units)
-            / context.scene.unit_settings.scale_length
-        )
-
-        """
-        Get script from text editor for injection
-        """
-        func = None
-        if context.scene.speckle.receive_script in bpy.data.texts:
-            mod = bpy.data.texts[context.scene.speckle.receive_script].as_module()
-            if hasattr(mod, "execute"):
-                func = mod.execute
-
-        """
-        Iterate through retrieved resources
-        """
-        bases_to_native(context, collections, scale, stream.id, func)
-
-        return {"FINISHED"}
-
-
-class SendStreamObjects(bpy.types.Operator):
-    """
-    Send stream objects
-    """
-
-    bl_idname = "speckle.send_stream_objects"
-    bl_label = "Send stream objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Send selected objects to active stream"
-
-    apply_modifiers: BoolProperty(name="Apply modifiers", default=True)
-    commit_message: StringProperty(
-        name="Message",
-        default="Pushed elements from Blender.",
-    )
-
-    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
-        if len(context.scene.speckle.users) > 0:
-            N = len(context.selected_objects)
-            if N == 1:
-                self.commit_message = "Pushed {} element from Blender.".format(N)
-            else:
-                self.commit_message = "Pushed {} elements from Blender.".format(N)
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        selected = context.selected_objects
-
-        if len(selected) < 1:
-            return {"CANCELLED"}
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, bstream = check
-        stream = user.streams[user.active_stream]
-        branch = stream.branches[int(stream.branch)]
-
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        scale = context.scene.unit_settings.scale_length / get_scale_length(
-            stream.units.lower()
-        )
-
-        """
-        Get script from text editor for injection
-        """
-        func = None
-        if context.scene.speckle.send_script in bpy.data.texts:
-            mod = bpy.data.texts[context.scene.speckle.send_script].as_module()
-            if hasattr(mod, "execute"):
-                func = mod.execute
-
-        export = {}
-
-        for obj in selected:
-
-            # if obj.type != 'MESH':
-            #     continue
-
-            new_object = obj
-
-            """
-            Run injected function
-            """
-            if func:
-                new_object = func(context.scene, obj)
-
-                if (
-                    new_object is None
-                ):  # Make sure that the injected function returned an object
-                    new_obj = obj
-                    _report("Script '{}' returned None.".format(func.__module__))
-                    continue
-
-            _report("Converting {}".format(obj.name))
-
-            ngons = obj.get("speckle_ngons_as_polylines", False)
-
-            if ngons:
-                converted = ngons_to_speckle_polylines(obj, scale)
-            else:
-                converted = convert_to_speckle(
-                    obj,
-                    scale,
-                    bpy.context.evaluated_depsgraph_get()
-                    if self.apply_modifiers
-                    else None,
-                )
-
-            if not converted:
-                continue
-
-            collection_name = obj.users_collection[0].name
-            if not export.get(collection_name):
-                export[collection_name] = []
-
-            export[collection_name].extend(converted)
-
-        base = Base()
-        for name, objects in export.items():
-            collection = bpy.data.collections.get(name)
-            hierarchy = get_collection_hierarchy(collection)
-            create_nested_hierarchy(base, hierarchy, objects)
-
-        transport = ServerTransport(stream.id, client)
-
-        obj_id = operations.send(
-            base,
-            [transport],
-        )
-        client.commit.create(
-            stream.id,
-            obj_id,
-            branch.name,
-            message=self.commit_message,
-            source_application="blender",
-        )
-
-        bpy.ops.speckle.load_user_streams()
-
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}
-
-
-class ViewStreamDataApi(bpy.types.Operator):
-    bl_idname = "speckle.view_stream_data_api"
-    bl_label = "Open Stream in Web"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "View the stream in the web browser"
-
-    def execute(self, context):
-
-        if len(context.scene.speckle.users) > 0:
-            user = context.scene.speckle.users[int(context.scene.speckle.active_user)]
-            if len(user.streams) > 0:
-                stream = user.streams[user.active_stream]
-
-                webbrowser.open("%s/streams/%s" % (user.server_url, stream.id), new=2)
-                return {"FINISHED"}
-        return {"CANCELLED"}
-
-
-class AddStreamFromURL(bpy.types.Operator):
-    """
-    Add / select a stream using its url
-    """
-
-    bl_idname = "speckle.add_stream_from_url"
-    bl_label = "Add stream from URL"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Add an existing stream by providing its URL"
-    stream_url: StringProperty(
-        name="Stream URL", default="https://speckle.xyz/streams/3073b96e86"
-    )
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "stream_url")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        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:
-            return {"CANCELLED"}
-        speckle.active_user = str(user_index)
-        user = speckle.users[user_index]
-
-        client = speckle_clients[user_index]
-        stream = client.stream.get(wrapper.stream_id)
-        if not isinstance(stream, Stream):
-            raise SpeckleException("Could not get the requested stream")
-
-        index, b_stream = next(
-            ((i, s) for i, s in enumerate(user.streams) if s.id == stream.id),
-            (None, None),
-        )
-
-        if index is None:
-            add_user_stream(user, stream)
-            user.active_stream, b_stream = next(
-                (i, s) for i, s in enumerate(user.streams) if s.id == stream.id
-            )
-        else:
-            user.active_stream = index
-
-        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()
-
-        return {"FINISHED"}
-
-
-class CreateStream(bpy.types.Operator):
-    """
-    Create new stream
-    """
-
-    bl_idname = "speckle.create_stream"
-    bl_label = "Create stream"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Create new stream"
-
-    stream_name: StringProperty(name="Stream name")
-    stream_description: StringProperty(
-        name="Stream description", default="This is a Blender stream."
-    )
-
-    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
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, bstream = check
-
-        client = speckle_clients[int(context.scene.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()
-
-        return {"FINISHED"}
-
-
-class DeleteStream(bpy.types.Operator):
-    """
-    Delete stream
-    """
-
-    bl_idname = "speckle.delete_stream"
-    bl_label = "Delete stream"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Delete selected stream permanently"
-
-    are_you_sure: BoolProperty(
-        name="Confirm",
-        default=False,
-    )
-
-    delete_collection: BoolProperty(name="Delete collection", default=False)
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-        col.prop(self, "are_you_sure")
-        col.prop(self, "delete_collection")
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        if len(context.scene.speckle.users) > 0:
-            return wm.invoke_props_dialog(self)
-
-        return {"CANCELLED"}
-
-    def execute(self, context):
-
-        if not self.are_you_sure:
-            return {"CANCELLED"}
-
-        self.are_you_sure = False
-
-        check = _check_speckle_client_user_stream(context.scene)
-        if check is None:
-            return {"CANCELLED"}
-
-        user, stream = check
-        client = speckle_clients[int(context.scene.speckle.active_user)]
-
-        client.stream.delete(id=stream.id)
-
-        if self.delete_collection:
-            col_name = "SpeckleStream_{}_{}".format(stream.name, stream.id)
-            if col_name in bpy.data.collections:
-                collection = bpy.data.collections[col_name]
-                bpy.data.collections.remove(collection)
-
-        bpy.ops.speckle.load_user_streams()
-        context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}
-
-
-class SelectOrphanObjects(bpy.types.Operator):
-    """
-    Select Speckle objects that don't belong to any stream
-    """
-
-    bl_idname = "speckle.select_orphans"
-    bl_label = "Select orphaned objects"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Select Speckle objects that don't belong to any stream"
-
-    def draw(self, context):
-        layout = self.layout
-
-    def execute(self, context):
-
-        for o in context.scene.objects:
-            if (
-                o.speckle.stream_id
-                and o.speckle.stream_id not in context.scene["speckle_streams"]
-            ):
-                o.select = True
-            else:
-                o.select = False
-
-        return {"FINISHED"}
-
-
-class UpdateGlobal(bpy.types.Operator):
-    """
-    DEPRECATED
-    Update all Speckle objects
-    """
-
-    bl_idname = "speckle.update_global"
-    bl_label = "Update Global"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Update all Speckle objects"
-
-    client = None
-
-    def draw(self, context):
-        layout = self.layout
-        row = layout.row()
-        label = row.label(text="Update everything.")
-
-    def execute(self, context):
-
-        client = context.scene.speckle.client
-
-        profiles = client.load_local_profiles()
-        if len(profiles) < 1:
-            raise ValueError("No profiles found.")
-        client.use_existing_profile(sorted(profiles.keys())[0])
-        context.scene.speckle.user = sorted(profiles.keys())[0]
-
-        for obj in context.scene.objects:
-            if obj.speckle.enabled:
-                UpdateObject(context.scene.speckle_client, obj)
-
-        context.scene.update()
-        return {"FINISHED"}
-
-
-class CopyStreamId(bpy.types.Operator):
-    """
-    Copy stream ID to clipboard
-    """
-
-    bl_idname = "speckle.stream_copy_id"
-    bl_label = "Copy stream ID"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy stream ID to clipboard"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) < 1:
-            return {"CANCELLED"}
-        user = speckle.users[int(speckle.active_user)]
-        if len(user.streams) < 1:
-            return {"CANCELLED"}
-        stream = user.streams[user.active_stream]
-        bpy.context.window_manager.clipboard = stream.id
-        return {"FINISHED"}
-
-
-class CopyCommitId(bpy.types.Operator):
-    """
-    Copy commit ID to clipboard
-    """
-
-    bl_idname = "speckle.commit_copy_id"
-    bl_label = "Copy commit ID"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy commit ID to clipboard"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) < 1:
-            return {"CANCELLED"}
-        user = speckle.users[int(speckle.active_user)]
-        if len(user.streams) < 1:
-            return {"CANCELLED"}
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        branch = stream.branches[int(stream.branch)]
-        if len(branch.commits) < 1:
-            return {"CANCELLED"}
-        commit = branch.commits[int(branch.commit)]
-        bpy.context.window_manager.clipboard = commit.id
-        return {"FINISHED"}
-
-
-class CopyBranchName(bpy.types.Operator):
-    """
-    Copy branch name to clipboard
-    """
-
-    bl_idname = "speckle.branch_copy_name"
-    bl_label = "Copy branch name"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Copy branch name to clipboard"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) < 1:
-            return {"CANCELLED"}
-        user = speckle.users[int(speckle.active_user)]
-        if len(user.streams) < 1:
-            return {"CANCELLED"}
-        stream = user.streams[user.active_stream]
-        if len(stream.branches) < 1:
-            return {"CANCELLED"}
-        branch = stream.branches[int(stream.branch)]
-        bpy.context.window_manager.clipboard = branch.name
-        return {"FINISHED"}

bpy_speckle/operators/users.py

@@ -1,133 +0,0 @@
-"""
-User account operators
-"""
-import bpy
-from bpy_speckle.functions import _report
-from bpy_speckle.clients import speckle_clients
-from specklepy.api.client import SpeckleClient
-from specklepy.api.credentials import get_local_accounts
-
-
-class LoadUsers(bpy.types.Operator):
-    """
-    Load all users from local user database
-    """
-
-    bl_idname = "speckle.users_load"
-    bl_label = "Load users"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-
-        _report("Loading users...")
-
-        users = context.scene.speckle.users
-
-        context.scene.speckle.users.clear()
-        speckle_clients.clear()
-
-        profiles = get_local_accounts()
-
-        for profile in profiles:
-            user = users.add()
-            user.server_name = profile.serverInfo.name or "Speckle Server"
-            user.server_url = profile.serverInfo.url
-            user.name = profile.userInfo.name
-            user.email = profile.userInfo.email
-            user.company = profile.userInfo.company or ""
-            user.authToken = profile.token
-            try:
-                client = SpeckleClient(
-                    host=profile.serverInfo.url,
-                    use_ssl="https" in profile.serverInfo.url,
-                )
-                client.authenticate(user.authToken)
-                speckle_clients.append(client)
-            except Exception as ex:
-                _report(ex)
-                users.remove(len(users) - 1)
-            if profile.isDefault:
-                context.scene.speckle.active_user = str(len(users) - 1)
-
-        context.scene.speckle.active_user_index = int(context.scene.speckle.active_user)
-        bpy.ops.speckle.load_user_streams()
-        bpy.context.view_layer.update()
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"FINISHED"}
-
-
-def add_user_stream(user, stream):
-    s = user.streams.add()
-    s.name = stream.name
-    s.id = stream.id
-    s.description = stream.description
-
-    if not stream.branches:
-        return
-
-    # branches = [branch for branch in stream.branches.items if branch.name != "globals"]
-    for b in stream.branches.items:
-        branch = s.branches.add()
-        branch.name = b.name
-
-        if not b.commits:
-            continue
-
-        for c in b.commits.items:
-            commit = branch.commits.add()
-            commit.id = commit.name = c.id
-            commit.message = c.message
-            commit.author_name = c.authorName
-            commit.author_id = c.authorId
-            commit.created_at = c.createdAt
-            commit.source_application = str(c.sourceApplication)
-
-    if hasattr(s, "baseProperties"):
-        s.units = stream.baseProperties.units
-    else:
-        s.units = "Meters"
-
-
-class LoadUserStreams(bpy.types.Operator):
-    """
-    Load all available streams for active user user
-    """
-
-    bl_idname = "speckle.load_user_streams"
-    bl_label = "Load user streams"
-    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "(Re)load all available user streams"
-
-    def execute(self, context):
-        speckle = context.scene.speckle
-
-        if len(speckle.users) > 0:
-            user = speckle.users[int(context.scene.speckle.active_user)]
-            client = speckle_clients[int(context.scene.speckle.active_user)]
-
-            try:
-                streams = client.stream.list(stream_limit=20)
-            except Exception as e:
-                _report("Failed to retrieve streams: {}".format(e))
-                return
-            if not streams:
-                _report("Failed to retrieve streams.")
-                return
-
-            user.streams.clear()
-
-            default_units = "Meters"
-
-            for s in streams:
-                sstream = client.stream.get(id=s.id)
-                add_user_stream(user, sstream)
-
-            bpy.context.view_layer.update()
-
-            return {"FINISHED"}
-
-        if context.area:
-            context.area.tag_redraw()
-        return {"CANCELLED"}

bpy_speckle/properties/__init__.py

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

bpy_speckle/properties/addon.py

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

bpy_speckle/properties/collection.py

@@ -1,19 +0,0 @@
-"""
-Collection properties
-"""
-import bpy
-
-
-class SpeckleCollectionSettings(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."),
-        ),
-    )
-    stream_id: bpy.props.StringProperty(default="")
-    name: bpy.props.StringProperty(default="")
-    units: bpy.props.StringProperty(default="")

bpy_speckle/properties/object.py

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

bpy_speckle/properties/scene.py

@@ -1,134 +0,0 @@
-"""
-Scene properties
-"""
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-    IntProperty,
-    PointerProperty,
-)
-
-
-class SpeckleSceneObject(bpy.types.PropertyGroup):
-    name: bpy.props.StringProperty(default="")
-
-
-class SpeckleCommitObject(bpy.types.PropertyGroup):
-    id: StringProperty(default="abc")
-    message: StringProperty(default="A simple commit")
-    author_name: StringProperty(default="Author name")
-    author_id: StringProperty(default="Author ID")
-    created_at: StringProperty(default="Today")
-    source_application: StringProperty(default="Unknown")
-
-
-class SpeckleBranchObject(bpy.types.PropertyGroup):
-    def get_commits(self, context):
-        if self.commits != None and len(self.commits) > 0:
-            return [
-                (str(i), commit.id, commit.message, i)
-                for i, commit in enumerate(self.commits)
-            ]
-        return [("0", "<none>", "<none>", 0)]
-
-    name: StringProperty(default="main")
-    commits: CollectionProperty(type=SpeckleCommitObject)
-    commit: EnumProperty(
-        name="Commit",
-        description="Active commit",
-        items=get_commits,
-    )
-
-
-class SpeckleStreamObject(bpy.types.PropertyGroup):
-    def get_branches(self, context):
-        if self.branches:
-            return [
-                (str(i), branch.name, branch.name, i)
-                for i, branch in enumerate(self.branches)
-                if branch.name != "globals"
-            ]
-        return [("0", "<none>", "<none>", 0)]
-
-    name: StringProperty(default="SpeckleStream")
-    description: StringProperty(default="No description provided.")
-    id: StringProperty(default="")
-    units: StringProperty(default="Meters")
-    query: StringProperty(default="")
-    branches: CollectionProperty(type=SpeckleBranchObject)
-    branch: EnumProperty(
-        name="Branch",
-        description="Active branch",
-        items=get_branches,
-    )
-
-
-class SpeckleUserObject(bpy.types.PropertyGroup):
-    server_name: StringProperty(default="SpeckleXYZ")
-    server_url: StringProperty(default="https://speckle.xyz")
-    name: StringProperty(default="Speckle User")
-    email: StringProperty(default="user@speckle.xyz")
-    company: StringProperty(default="SpeckleSystems")
-    authToken: StringProperty(default="")
-    streams: CollectionProperty(type=SpeckleStreamObject)
-    active_stream: IntProperty(default=0)
-
-
-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=[],
-    )
-
-    users: CollectionProperty(type=SpeckleUserObject)
-
-    def get_users(self, context):
-        return [
-            (str(i), "{} ({})".format(user.email, user.server_name), user.server_url, i)
-            for i, user in enumerate(self.users)
-        ]
-
-    def set_user(self, context):
-        bpy.ops.speckle.load_user_streams()
-
-    active_user: EnumProperty(
-        items=get_users,
-        name="User",
-        description="Select user",
-        update=set_user,
-        get=None,
-        set=None,
-    )
-
-    objects: CollectionProperty(type=SpeckleSceneObject)
-
-    scale: FloatProperty(default=0.001)
-
-    user: StringProperty(
-        name="User",
-        description="Current user.",
-        default="Speckle User",
-    )
-
-    receive_script: EnumProperty(
-        name="Receive script",
-        description="Script to run when receiving stream objects.",
-        items=get_scripts,
-    )
-
-    send_script: EnumProperty(
-        name="Send script",
-        description="Script to run when sending stream objects.",
-        items=get_scripts,
-    )

bpy_speckle/ui/__init__.py

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

bpy_speckle/ui/object.py

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

bpy_speckle/ui/view3d.py

@@ -1,275 +0,0 @@
-"""
-Speckle UI elements for the 3d viewport
-"""
-
-
-import bpy
-from bpy.props import (
-    StringProperty,
-    BoolProperty,
-    FloatProperty,
-    CollectionProperty,
-    EnumProperty,
-)
-
-import datetime
-
-"""
-Compatibility 
-TODO: evaluate if we should still support Blender <2.80
-"""
-
-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 stream 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="Streams", icon_value=0)
-
-
-class VIEW3D_PT_SpeckleUser(bpy.types.Panel):
-    """
-    Speckle Users UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "User"
-
-    def draw(self, context):
-        speckle = context.scene.speckle
-
-        layout = self.layout
-        col = layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No users found.")
-        else:
-            col.prop(speckle, "active_user", text="")
-            user = speckle.users[int(speckle.active_user)]
-            col.label(text="{} ({})".format(user.server_name, user.server_url))
-            col.label(text="{} ({})".format(user.name, user.email))
-
-
-class VIEW3D_PT_SpeckleStreams(bpy.types.Panel):
-    """
-    Speckle Streams UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Streams"
-
-    def draw(self, context):
-        speckle = context.scene.speckle
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No stream data.")
-        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.delete_stream", text="", icon="REMOVE")
-            row.operator("speckle.load_user_streams", text="", icon="FILE_REFRESH")
-
-
-class VIEW3D_PT_SpeckleActiveStream(bpy.types.Panel):
-    """
-    Speckle Active Streams UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Active stream"
-
-    def draw(self, context):
-        speckle = context.scene.speckle
-        col = self.layout.column()
-
-        if len(speckle.users) < 1:
-            col.label(text="No stream data.")
-        else:
-            user = speckle.users[int(speckle.active_user)]
-            if len(user.streams) < 1:
-                col.label(text="No active stream.")
-            else:
-                stream = user.streams[user.active_stream]
-                # user.active_stream = min(user.active_stream, len(user.streams) - 1)
-                row = col.row()
-                row.label(text="{} ({})".format(stream.name, stream.id))
-                row.operator("speckle.stream_copy_id", text="", icon="COPY_ID")
-                col.separator()
-
-                row = col.row()
-                row.prop(stream, "branch", text="")
-                row.operator("speckle.branch_copy_name", text="", icon="COPY_ID")
-
-                if len(stream.branches) > 0:
-                    branch = stream.branches[int(stream.branch)]
-
-                    row = col.row()
-                    row.prop(branch, "commit", text="")
-                    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.datetime.strptime(
-                            commit.created_at, "%Y-%m-%dT%H:%M:%S.%fZ"
-                        )
-                        col.label(text="{}".format(dt.ctime()))
-                        col.label(
-                            text="{} ({})".format(commit.author_name, commit.author_id)
-                        )
-                        col.label(text=commit.source_application)
-                else:
-                    col.label(text="No branches 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="")
-                area.prop(stream, "query", text="Filter")
-
-                col.separator()
-
-                row = col.row(align=True)
-                subcol = row.column()
-                subcol.label(text="Units:")
-                subcol = row.column()
-                subcol.label(text=stream.units)
-
-                col.label(text="Description:")
-                area = col.box()
-                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 Stream in Web")
-
-
-class VIEW3D_PT_SpeckleHelp(bpy.types.Panel):
-    """
-    Speckle Help UI panel in the 3d viewport
-    """
-
-    bl_space_type = "VIEW_3D"
-    bl_region_type = Region
-    bl_category = "Speckle"
-    bl_context = "objectmode"
-    bl_label = "Help"
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-
-        col.operator("speckle.open_speckle_guide")
-        col.separator()
-        col.operator("speckle.open_speckle_tutorials")
-        col.separator()
-        col.operator("speckle.open_speckle_forum")

bpy_speckle/util.py

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

export_dependencies.sh

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

patch_version.py

@@ -1,65 +1,47 @@
 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(".")
 
-def patch_connector(tag):
-    """Patches the connector version within the connector init file"""
-    bpy_file = "bpy_speckle/__init__.py"
-    tag = tag.split(".")
-
-    with open(bpy_file, "r") as file:
+    with open(FILE_PATH, "r") as file:
         lines = file.readlines()
 
         for (index, line) in enumerate(lines):
             if '"version":' in line:
-                lines[index] = f'    "version": ({tag[0]}, {tag[1]}, {tag[2]}),\n'
-                print(f"Patched connector version number in {bpy_file}")
+                lines[index] = f'    "version": ({version[0]}, {version[1]}, {version[2]}),\n'
+
+        with open(FILE_PATH, "w") as file:
+            file.writelines(lines)
+
+def patch_manifest(simple_version: str):
+    """Patches the connector version within the connector init file"""
+    FILE_PATH = "bpy_speckle/blender_manifest.toml"
+    version = simple_version.split(".")
+
+    with open(FILE_PATH, "r") as file:
+        lines = file.readlines()
+
+        for (index, line) in enumerate(lines):
+            if line.startswith('version ='):
+                lines[index] = f'version = "{version[0]}.{version[1]}.{version[2]}",\n'
+                print(f"Patched connector version number in {FILE_PATH}")
                 break
 
-        with open(bpy_file, "w") as file:
+        with open(FILE_PATH, "w") as file:
             file.writelines(lines)
 
-
-def patch_installer(tag):
-    """Patches the installer with the correct connector version and specklepy version"""
-    iss_file = "speckle-sharp-ci-tools/blender.iss"
-
-    py_tag = get_specklepy_version()
-    with open(iss_file, "r") as file:
-        lines = file.readlines()
-        lines.insert(11, f'#define SpecklepyVersion "{py_tag}"\n')
-        lines.insert(11, f'#define AppVersion "{tag}"\n')
-
-        with open(iss_file, "w") as file:
-            file.writelines(lines)
-            print(f"Patched installer with connector v{tag} and specklepy v{py_tag}")
-
-
-def get_specklepy_version():
-    """Get version of specklepy to install from the pyproject.toml"""
-    version = "2.3.3"
-    with open("pyproject.toml", "r") as f:
-        lines = [line for line in f if line.startswith("specklepy = ")]
-        if not lines:
-            raise Exception("Could not find specklepy in pyproject.toml")
-        match = re.search(r"[0-9]+(\.[0-9]+)*", lines[0])
-        if match:
-            version = match[0]
-    return version
-
-
 def main():
-    if len(sys.argv) < 2:
-        print(get_specklepy_version())
-        return
-
     tag = sys.argv[1]
-    if not re.match(r"[0-9]+(\.[0-9]+)*$", tag):
+    if not re.match(r"([0-9]+)\.([0-9]+)\.([0-9]+)", tag):
         raise ValueError(f"Invalid tag provided: {tag}")
 
     print(f"Patching version: {tag}")
-    patch_connector(tag)
-    patch_installer(tag)
+    simple_version = tag.split("-")[0]
+    patch_addon(simple_version)
+    patch_manifest(simple_version)
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -1,22 +1,16 @@
-[tool.poetry]
+[project]
 name = "speckle-blender"
-version = "2.0.0"
-description = "the Speckle 2.0 connector for Blender!"
-authors = ["izzy lyseggen <izzy.lyseggen@gmail.com>"]
+version = "3.0.0"
+description = "Next-Gen Speckle connector for Blender!"
+requires-python = ">=3.11.9, <4.0.0"
 license = "Apache-2.0"
+dependencies = [
+    "specklepy==3.0.0a15",
+]
 
-[tool.poetry.dependencies]
-python = ">=3.7,<3.8"
-specklepy = "^2.5.1"
+[dependency-groups]
+dev = [
+    "fake-bpy-module-latest>=20240524,<20240525",
+    "ruff>=0.4.4,<0.5",
+]
 
-[tool.poetry.dev-dependencies]
-devtools = "^0.6.1"
-numpy = "^1.20.2"
-bpy = "^2.82.1"
-bpy-build = "^2.1.0"
-black = "^21.12b0"
-pylint = "^2.12.2"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

uv.lock

@@ -0,0 +1,788 @@
+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 },
+]