feat(metrics): Introduce sync metrics (#462)

* sync metrics tracking

* fix

.github/workflows/pr.yml

@@ -1,12 +1,63 @@
-name: "Specklepy test and build"
+name: "Specklepy test"
 on:
+  workflow_call:
+    secrets:
+      CODECOV_TOKEN:
+        required: true
   pull_request:
     branches:
-      - "v3-dev"
+      - "main"
 
 jobs:
-  build-and-test:
-    name: build-and-test
+  test-internal: # Run integration tests against the internal server image
+    name: Test (internal)
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Install the project
+        run: uv sync --all-extras --dev
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: "ghcr.io"
+          username: ${{ github.actor }}
+          password: ${{ github.token }}
+
+      - name: Run Speckle Server
+        run: docker compose --file docker-compose-internal.yml up --detach --wait
+
+      - name: Run tests
+        run: uv run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
+
+      - uses: codecov/codecov-action@v5
+        if: matrix.python-version == 3.12
+        with:
+          fail_ci_if_error: true # optional (default = false)
+          files: ./reports/test-results.xml # optional
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Minimize uv cache
+        run: uv cache prune --ci
+
+  test-public: # Run integration tests against the public server image
+    name: Test (public)
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -38,17 +89,10 @@ jobs:
         run: uv run pre-commit run --all-files
 
       - name: Run Speckle Server
-        run: docker compose up --detach --wait
+        run: docker compose --file docker-compose.yml up --detach --wait
 
       - name: Run tests
         run: uv run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
 
-      - uses: codecov/codecov-action@v5
-        if: matrix.python-version == 3.13
-        with:
-          fail_ci_if_error: true # optional (default = false)
-          files: ./reports/test-results.xml # optional
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Minimize uv cache
         run: uv cache prune --ci

.github/workflows/publish.yml

@@ -2,63 +2,20 @@ name: "Publish Python Package"
 on:
   push:
     branches:
-      - "v3-dev"
+      - "main"
     tags:
       - "3.*.*"
 
 jobs:
-  build-and-test:
-    name: continuous-integration
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version:
-          - "3.10"
-          - "3.11"
-          - "3.12"
-          - "3.13"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install uv and set the python version
-        uses: astral-sh/setup-uv@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-          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: Run Speckle Server
-        run: docker compose up -d
-
-      # - name: Run tests
-      #   run: uv run pytest --cov --cov-report xml:reports/coverage.xml --junitxml=reports/test-results.xml
-
-      # - uses: codecov/codecov-action@v5
-      #   if: matrix.python-version == 3.13
-      #   with:
-      #     fail_ci_if_error: true # optional (default = false)
-      #     files: ./reports/test-results.xml # optional
-      #     token: ${{ secrets.CODECOV_TOKEN }}
-
-      - name: Minimize uv cache
-        run: uv cache prune --ci
+  test:
+    uses: "./.github/workflows/pr.yml"
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   publish-package:
     name: "Build and Publish Python Package"
     runs-on: ubuntu-latest
-    needs: build-and-test
+    needs: test
 
     # set the environment based on what triggered the workflow
     environment:
@@ -79,7 +36,7 @@ jobs:
       - name: "Build package artifacts"
         run: uv build
 
-      # Logic for TestPyPI (on v3-dev branch push)
+      # Logic for TestPyPI (on main branch push)
       - name: "Publish to TestPyPI"
         if: ${{ github.ref_type == 'branch' }}
         run: uv publish --index test

.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+    "recommendations": [
+        "ms-python.python",
+        "charliermarsh.ruff"
+    ]
+}

README.md

@@ -11,7 +11,11 @@
     The Python SDK
 </h3>
 
-<p align="center"><a href="https://codecov.io/gh/specklesystems/specklepy"><img src="https://codecov.io/gh/specklesystems/specklepy/branch/main/graph/badge.svg?token=8KQFL5N0YF" alt="Codecov"></a></p>
+<p align="center">
+  <a href="https://pypi.org/project/specklepy/"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/specklepy"></a>
+  <a href="https://codecov.io/gh/specklesystems/specklepy"><img src="https://codecov.io/gh/specklesystems/specklepy/branch/main/graph/badge.svg?token=8KQFL5N0YF" alt="Codecov"></a>
+  <a href="https://github.com/specklesystems/specklepy/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/specklesystems/specklepy"></a>
+</p>
 
 # Repo structure
 

docker-compose-internal.yml

@@ -0,0 +1,119 @@
+name: "speckle-server"
+
+services:
+  ####
+  # Speckle Server dependencies
+  #######
+  postgres:
+    image: "postgres:16.4-alpine3.20@sha256:d898b0b78a2627cb4ee63464a14efc9d296884f1b28c841b0ab7d7c42f1fffdf"
+    restart: always
+    environment:
+      POSTGRES_DB: speckle
+      POSTGRES_USER: speckle
+      POSTGRES_PASSWORD: speckle
+    volumes:
+      - ./.volumes/postgres-data:/var/lib/postgresql/data/
+    healthcheck:
+      # the -U user has to match the POSTGRES_USER value
+      test: ["CMD-SHELL", "pg_isready -U speckle"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+  redis:
+    image: "valkey/valkey:8.1-alpine@sha256:0d27f0bca0249f61d060029a6aaf2e16b2c417d68d02a508e1dfb763fa2948b4"
+    restart: always
+    volumes:
+      - ./.volumes/redis-data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+  minio:
+    image: "minio/minio:RELEASE.2023-10-25T06-33-25Z"
+    command: server /data --console-address ":9001"
+    restart: always
+    volumes:
+      - ./.volumes/minio-data:/data
+    ports:
+      - '127.0.0.1:9000:9000'
+      - '127.0.0.1:9001:9001'
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "curl -s -o /dev/null http://127.0.0.1:9000/minio/index.html",
+        ]
+      interval: 5s
+      timeout: 30s
+      retries: 30
+      start_period: 10s
+
+  speckle-server:
+    image: ghcr.io/specklesystems/speckle-server:latest
+    restart: always
+    healthcheck:
+      test:
+        - CMD
+        - /nodejs/bin/node
+        - -e
+        - "try { require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/readiness', method: 'GET', timeout: 2000 }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(Number(res.statusCode != 200 || body.toLowerCase().includes('error')));}); }).end(); } catch { process.exit(1); }"
+      interval: 10s
+      timeout: 10s
+      retries: 3
+      start_period: 90s
+    ports:
+      - "0.0.0.0:3000:3000"
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+    environment:
+      # TODO: Change this to the URL of the speckle server, as accessed from the network
+      CANONICAL_URL: "http://127.0.0.1:8080"
+      SPECKLE_AUTOMATE_URL: "http://127.0.0.1:3030"
+      FRONTEND_ORIGIN: "http://127.0.0.1:8081"
+
+      # TODO: Change thvolumes:
+      REDIS_URL: "redis://redis"
+
+      S3_ENDPOINT: "http://minio:9000"
+      S3_PUBLIC_ENDPOINT: "http://127.0.0.1:9000"
+      S3_ACCESS_KEY: "minioadmin"
+      S3_SECRET_KEY: "minioadmin"
+      S3_BUCKET: "speckle-server"
+      S3_CREATE_BUCKET: "true"
+
+      FILE_SIZE_LIMIT_MB: 100
+      MAX_PROJECT_MODELS_PER_PAGE: 500
+
+      # TODO: Change this to a unique secret for this server
+      SESSION_SECRET: "TODO:ReplaceWithLongString"
+
+      STRATEGY_LOCAL: "true"
+      DEBUG: "speckle:*"
+
+      POSTGRES_URL: "postgres"
+      POSTGRES_USER: "speckle"
+      POSTGRES_PASSWORD: "speckle"
+      POSTGRES_DB: "speckle"
+      ENABLE_MP: "false"
+
+      LOG_PRETTY: "true"
+
+      FF_NEXT_GEN_FILE_IMPORTER_ENABLED: "true"
+      FF_LARGE_FILE_IMPORTS_ENABLED: "true"
+
+networks:
+  default:
+    name: speckle-server
+
+volumes:
+  postgres-data:
+  redis-data:
+  minio-data:

docker-compose.yml

@@ -1,4 +1,3 @@
-version: "3.9"
 name: "speckle-server"
 
 services:
@@ -13,7 +12,7 @@ services:
       POSTGRES_USER: speckle
       POSTGRES_PASSWORD: speckle
     volumes:
-      - postgres-data:/var/lib/postgresql/data/
+      - ./.volumes/postgres-data:/var/lib/postgresql/data/
     healthcheck:
       # the -U user has to match the POSTGRES_USER value
       test: ["CMD-SHELL", "pg_isready -U speckle"]
@@ -22,10 +21,10 @@ services:
       retries: 30
 
   redis:
-    image: "redis:6.0-alpine"
+    image: "valkey/valkey:8.1-alpine@sha256:0d27f0bca0249f61d060029a6aaf2e16b2c417d68d02a508e1dfb763fa2948b4"
     restart: always
     volumes:
-      - redis-data:/data
+      - ./.volumes/redis-data:/data
     healthcheck:
       test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
       interval: 5s
@@ -37,7 +36,10 @@ services:
     command: server /data --console-address ":9001"
     restart: always
     volumes:
-      - minio-data:/data
+      - ./.volumes/minio-data:/data
+    ports:
+      - '127.0.0.1:9000:9000'
+      - '127.0.0.1:9001:9001'
     healthcheck:
       test:
         [
@@ -57,7 +59,7 @@ services:
         - CMD
         - /nodejs/bin/node
         - -e
-        - "try { require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/readiness', method: 'GET', timeout: 2000 }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(res.statusCode != 200 || body.toLowerCase().includes('error'));}); }).end(); } catch { process.exit(1); }"
+        - "try { require('node:http').request({headers: {'Content-Type': 'application/json'}, port:3000, hostname:'127.0.0.1', path:'/readiness', method: 'GET', timeout: 2000 }, (res) => { body = ''; res.on('data', (chunk) => {body += chunk;}); res.on('end', () => {process.exit(Number(res.statusCode != 200 || body.toLowerCase().includes('error')));}); }).end(); } catch { process.exit(1); }"
       interval: 10s
       timeout: 10s
       retries: 3
@@ -81,6 +83,7 @@ services:
       REDIS_URL: "redis://redis"
 
       S3_ENDPOINT: "http://minio:9000"
+      S3_PUBLIC_ENDPOINT: "http://127.0.0.1:9000"
       S3_ACCESS_KEY: "minioadmin"
       S3_SECRET_KEY: "minioadmin"
       S3_BUCKET: "speckle-server"
@@ -101,6 +104,11 @@ services:
       POSTGRES_DB: "speckle"
       ENABLE_MP: "false"
 
+      LOG_PRETTY: "true"
+
+      FF_NEXT_GEN_FILE_IMPORTER_ENABLED: "true"
+      FF_LARGE_FILE_IMPORTS_ENABLED: "true"
+
 networks:
   default:
     name: speckle-server

mise.toml

@@ -0,0 +1,6 @@
+[tools]
+python = "3.13.7"
+
+[settings]
+experimental = true
+python.uv_venv_auto = true

pyproject.toml

@@ -2,7 +2,7 @@
 dynamic = ["version"]
 # version = "3.0.0a1"
 name = "specklepy"
-description = "The Python SDK for Speckle 2.0"
+description = "The Python SDK for Speckle"
 readme = "README.md"
 authors = [{ name = "Speckle Systems", email = "devops@speckle.systems" }]
 license = { text = "Apache-2.0" }
@@ -11,13 +11,16 @@ dependencies = [
     "appdirs>=1.4.4",
     "attrs>=24.3.0",
     "deprecated>=1.2.15",
-    "gql[requests,websockets]>=3.5.0",
+    "gql[requests,websockets]>=3.5.0,<4.0.0",
     "httpx>=0.28.1",
     "pydantic>=2.10.5",
     "pydantic-settings>=2.7.1",
     "ujson>=5.10.0",
 ]
 
+[project.optional-dependencies]
+speckleifc = ["ifcopenshell>=0.8.3.post2"]
+
 [dependency-groups]
 dev = [
     "commitizen>=4.1.0",
@@ -48,9 +51,12 @@ build-backend = "hatchling.build"
 source = "vcs"
 
 [tool.hatch.build.targets.wheel]
-only-include = ["src"]
+only-include = ["src", "licenses"]
 sources = ["src"]
 
+[tool.hatch.build.targets.sdist]
+include = ["src", "licenses"]
+
 [tool.hatch.version.raw-options]
 local_scheme = "no-local-version"
 

src/speckle_automate/automation_context.py

@@ -268,7 +268,7 @@ class AutomationContext:
         print(f"Reporting run status with content: {params}")
         self.speckle_client.httpclient.execute(query, params)
 
-    def store_file_result(self, file_path: Union[Path, str]) -> None:
+    def store_file_result(self, file_path: Union[Path, str]) -> str:
         """Save a file attached to the project of this automation."""
         path_obj = (
             Path(file_path).resolve() if isinstance(file_path, str) else file_path
@@ -310,6 +310,8 @@ class AutomationContext:
             [upload_result.blob_id for upload_result in upload_response.upload_results]
         )
 
+        return upload_response.upload_results[0].blob_id
+
     def mark_run_failed(self, status_message: str) -> None:
         """Mark the current run a failure."""
         self._mark_run(AutomationStatus.FAILED, status_message)

src/speckle_automate/fixtures.py

@@ -1,8 +1,5 @@
 """Some useful helpers for working with automation data."""
 
-import secrets
-import string
-
 import pytest
 from gql import gql
 from pydantic import Field
@@ -140,12 +137,6 @@ def test_automation_run_data(
     return create_test_automation_run_data(speckle_client, test_automation_environment)
 
 
-def crypto_random_string(length: int) -> str:
-    """Generate a semi crypto random string of a given length."""
-    alphabet = string.ascii_letters + string.digits
-    return "".join(secrets.choice(alphabet) for _ in range(length)).lower()
-
-
 __all__ = [
     "test_automation_environment",
     "test_automation_token",

src/speckleifc/__main__.py

@@ -0,0 +1,61 @@
+import json
+import time
+import traceback
+from argparse import ArgumentParser
+from os import getenv
+
+from speckleifc.main import open_and_convert_file
+from specklepy.core.api.client import SpeckleClient
+from specklepy.logging import metrics
+
+
+def cmd_line_import() -> None:
+    parser = ArgumentParser(
+        prog="speckleifc",
+        description="imports a file",
+    )
+    parser.add_argument("file_path")
+    parser.add_argument("output_path")
+    parser.add_argument("project_id")
+    parser.add_argument("version_message")
+    parser.add_argument("model_id")
+    # parser.add_argument("model_name")
+    # parser.add_argument("region_name")
+
+    args = parser.parse_args()
+
+    TOKEN = getenv("USER_TOKEN")
+    assert TOKEN is not None
+    SERVER_URL = getenv("SPECKLE_SERVER_URL") or "http://127.0.0.1:3000"
+
+    metrics.set_host_app(
+        "ifc",
+    )
+
+    try:
+        client = SpeckleClient(SERVER_URL, use_ssl=not SERVER_URL.startswith("http://"))
+        client.authenticate_with_token(TOKEN)
+        project = client.project.get(args.project_id)
+
+        version = open_and_convert_file(
+            args.file_path,
+            project,
+            args.version_message,
+            args.model_id,
+            client,
+        )
+        with open(args.output_path, "w") as f:
+            json.dump({"success": True, "commitId": version.id}, f)
+    except Exception as e:
+        error_msg = f"IFC Importer failed with exception:\n{traceback.format_exc()}"
+        print(error_msg)
+
+        # Write error result
+        with open(args.output_path, "w") as f:
+            json.dump({"success": False, "error": str(e)}, f)
+
+
+if __name__ == "__main__":
+    start = time.time()
+    cmd_line_import()
+    print(f"Total time (including cleanup): {(time.time() - start) * 1000}ms")

src/speckleifc/converter/data_object_converter.py

@@ -0,0 +1,35 @@
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+from speckleifc.property_extraction import extract_properties
+from specklepy.objects.base import Base
+from specklepy.objects.data_objects import DataObject
+
+
+def data_object_to_speckle(
+    display_value: list[Base],
+    step_element: entity_instance,
+    children: list[Base],
+    current_storey: str | None = None,
+) -> DataObject:
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or guid)
+
+    properties = extract_properties(step_element)
+
+    # Add building storey information if available and not a building storey itself
+    if current_storey and not step_element.is_a("IfcBuildingStorey"):
+        properties["Building Storey"] = current_storey
+
+    data_object = DataObject(
+        applicationId=guid,
+        properties=properties,
+        name=name or guid,
+        displayValue=display_value,
+    )
+
+    data_object["@elements"] = children
+    data_object["ifcType"] = step_element.is_a()
+
+    return data_object

src/speckleifc/converter/geometry_converter.py

@@ -0,0 +1,130 @@
+from collections import defaultdict
+from collections.abc import Sequence
+from typing import cast
+
+from ifcopenshell.ifcopenshell_wrapper import (
+    Triangulation,
+    TriangulationElement,
+    colour,
+    style,
+)
+
+from speckleifc.render_material_proxy_manager import RenderMaterialProxyManager
+from specklepy.objects.base import Base
+from specklepy.objects.geometry import Mesh
+from specklepy.objects.other import RenderMaterial
+
+
+def geometry_to_speckle(
+    shape: TriangulationElement, render_material_manager: RenderMaterialProxyManager
+) -> list[Base]:
+    geometry = cast(Triangulation, shape.geometry)
+    materials = cast(Sequence[style], geometry.materials)
+    MESH_COUNT = max(len(materials), 1)
+
+    material_ids = cast(Sequence[int], geometry.material_ids)
+    faces = cast(Sequence[int], geometry.faces)
+    verts = cast(Sequence[float], geometry.verts)
+    normals = cast(Sequence[float], geometry.normals)
+
+    FACE_COUNT = len(material_ids)
+
+    if len(faces) != FACE_COUNT * 3 or FACE_COUNT == 0:
+        # Not really expected, but occasionally some meshes fail to triangulate
+        return []
+
+    mapped_meshes = _pre_alloc_mesh_lists(shape, material_ids, MESH_COUNT)
+    for i, mesh in enumerate(mapped_meshes):
+        material = _material_to_speckle(materials[i])
+        render_material_manager.add_mesh_material_mapping(material, mesh)
+
+    mapped_faces_pointers = [0] * MESH_COUNT
+    mapped_vertices_pointers = [0] * MESH_COUNT
+    mapped_index_counters = [0] * MESH_COUNT
+
+    i = 0
+    face_index = 0
+    while i < FACE_COUNT:
+        mesh_index = material_ids[i]
+        mesh: Mesh = mapped_meshes[mesh_index]
+
+        face_ptr = mapped_faces_pointers[mesh_index]
+        vert_ptr = mapped_vertices_pointers[mesh_index]
+
+        # Add triangle
+        mesh.faces[face_ptr] = 3
+        for j in range(3):
+            # Add vert
+            mesh.faces[face_ptr + 1 + j] = mapped_index_counters[mesh_index] + j
+            vert_index = faces[face_index + j] * 3
+            mapped_vert_offset = vert_ptr + (j * 3)
+
+            mesh.vertices[mapped_vert_offset] = verts[vert_index]
+            mesh.vertices[mapped_vert_offset + 1] = verts[vert_index + 1]
+            mesh.vertices[mapped_vert_offset + 2] = verts[vert_index + 2]
+
+            mesh.vertexNormals[mapped_vert_offset] = normals[vert_index]
+            mesh.vertexNormals[mapped_vert_offset + 1] = normals[vert_index + 1]
+            mesh.vertexNormals[mapped_vert_offset + 2] = normals[vert_index + 2]
+
+        i += 1
+        face_index += 3  # number of items in the faces list we just jumped over
+
+        mapped_index_counters[mesh_index] += (
+            3  # number of verts we just added to the mesh.vertices i.e. the next index
+        )
+        mapped_faces_pointers[mesh_index] += (
+            4  # number of item's we've just added to the mesh.faces list
+        )
+        mapped_vertices_pointers[mesh_index] += (
+            9  # number of item's we've just added to the mesh.vertices list
+        )
+
+    return mapped_meshes  # type: ignore
+
+
+def _material_to_speckle(material: style) -> RenderMaterial:
+    return RenderMaterial(
+        applicationId=material.calc_hash(),
+        name=material.name,
+        diffuse=_color_to_argb(material.diffuse),
+        opacity=1 - material.transparency if material.has_transparency() else 1,
+    )
+
+
+def _color_to_argb(colour: colour) -> int:
+    # Clamp values to [0, 1] and convert to 0–255
+    a_int = 255
+    r_int = max(0, min(255, int(round(colour.r() * 255))))
+    g_int = max(0, min(255, int(round(colour.g() * 255))))
+    b_int = max(0, min(255, int(round(colour.b() * 255))))
+
+    return (a_int << 24) | (r_int << 16) | (g_int << 8) | b_int
+
+
+def _pre_alloc_mesh_lists(
+    shape: TriangulationElement, material_ids: Sequence[int], MESH_COUNT: int
+) -> list[Mesh]:
+    """
+    This is a performance optimisation to pre-size the lists
+    since we're expecting potential hundreds of thousands of verts in a single model
+    This is very much in the hot path, so worth the extra bit of convoluted logic
+    """
+    appId = cast(str, shape.guid)
+
+    material_face_counts = defaultdict(int)
+    for mat_id in material_ids:
+        material_face_counts[mat_id] += 1
+
+    meshes = []
+    for mat_id in range(MESH_COUNT):
+        face_count = material_face_counts.get(mat_id, 0)
+        mesh = Mesh(
+            units="m",
+            vertices=[-1] * (face_count * 9),
+            vertexNormals=[-1] * (face_count * 9),
+            faces=[-1] * (face_count * 4),  # 1 marker + 3 vertex indices
+            applicationId=f"{appId}_mat{mat_id}",
+        )
+        meshes.append(mesh)
+    return meshes

src/speckleifc/converter/project_converter.py

@@ -0,0 +1,23 @@
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+from specklepy.objects.base import Base
+from specklepy.objects.models.collections.collection import Collection
+
+
+def project_to_speckle(
+    step_element: entity_instance, children: list[Base]
+) -> Collection:
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or step_element.LongName or guid)
+
+    project = Collection(applicationId=guid, name=name, elements=children)
+
+    project["ifcType"] = step_element.is_a()
+    project["description"] = step_element.Description
+    project["objectType"] = step_element.ObjectType
+    project["longName"] = step_element.LongName
+    project["phase"] = step_element.Phase
+
+    return project

src/speckleifc/converter/spatial_element_converter.py

@@ -0,0 +1,54 @@
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+from speckleifc.property_extraction import extract_properties
+from specklepy.objects.base import Base
+from specklepy.objects.data_objects import DataObject
+from specklepy.objects.models.collections.collection import Collection
+
+
+def spatial_element_to_speckle(
+    display_value: list[Base],
+    step_element: entity_instance,
+    relational_children: list[Base],
+    current_storey: str | None = None,
+) -> Collection:
+    direct_geometry = _convert_as_data_object(
+        display_value, step_element, current_storey
+    )
+    all_children = [direct_geometry] + relational_children
+
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or step_element.LongName or guid)
+
+    data_object = Collection(applicationId=guid, name=name, elements=all_children)
+    data_object["ifcType"] = step_element.is_a()
+
+    return data_object
+
+
+def _convert_as_data_object(
+    display_value: list[Base],
+    step_element: entity_instance,
+    current_storey: str | None = None,
+) -> DataObject:
+    guid = cast(str, step_element.GlobalId)
+    name = cast(str, step_element.Name or step_element.LongName or guid)
+
+    properties = extract_properties(step_element)
+
+    # Add building storey information if available and not a building storey itself
+    if current_storey and not step_element.is_a("IfcBuildingStorey"):
+        properties["Building Storey"] = current_storey
+
+    data_object = DataObject(
+        applicationId=guid,
+        properties=properties,
+        name=name,
+        displayValue=display_value,
+    )
+
+    data_object["ifcType"] = step_element.is_a()
+
+    return data_object

src/speckleifc/ifc_geometry_processing.py

@@ -0,0 +1,52 @@
+import multiprocessing
+
+from ifcopenshell import SchemaError, file, ifcopenshell_wrapper, open, sqlite
+from ifcopenshell.geom import iterator, settings
+
+from specklepy.logging.exceptions import SpeckleException
+
+
+def _create_iterator_settings() -> settings:
+    ifc_settings = settings()
+    # triangles for now, speckle does support n-gons, but may be less performant
+    ifc_settings.set("triangulation-type", ifcopenshell_wrapper.TRIANGLE_MESH)
+    # no need to weld verts
+    ifc_settings.set("weld-vertices", False)
+    # Speckle meshes are all in world coords
+    ifc_settings.set("use-world-coords", True)
+    # Tiny performance improvement,
+    ifc_settings.set("no-wire-intersection-check", True)
+    # Rendermaterials inherit the material names instead of type + unique id
+    ifc_settings.set("use-material-names", True)
+
+    # IfcOpenshell defaults to 0.001mm here, which leads to very dense meshes.
+    # lowering the mesh quality a bit here leads to meshes
+    # that are still much higher quality than webifc
+
+    # We still need to experiment with the affect on memory usage
+    # It may be desirable to lower this further, and increase the angular deflection
+    # to compensate. This would allow large meshes to be lower quality,
+    # while keeping small meshes relatively similar.
+    ifc_settings.set("mesher-linear-deflection", 0.2)
+
+    return ifc_settings
+
+
+def open_ifc(file_path: str) -> file:
+    try:
+        ifc_file = open(file_path)
+    except SchemaError:
+        raise
+    except FileNotFoundError:
+        raise
+    except Exception as ex:
+        raise SpeckleException("File could not be opened as an IFC file") from ex
+
+    if isinstance(ifc_file, file):
+        return ifc_file
+    else:
+        raise SpeckleException(f"file at {file_path} is not a compatible ifc file type")
+
+
+def create_geometry_iterator(ifc_file: file | sqlite) -> iterator:
+    return iterator(_create_iterator_settings(), ifc_file, multiprocessing.cpu_count())

src/speckleifc/ifc_openshell_helpers.py

@@ -0,0 +1,31 @@
+from collections.abc import Generator, Iterable
+from itertools import chain
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+
+
+def get_children(step_element: entity_instance) -> Generator[entity_instance]:
+    yield from chain(
+        get_spatial_children(step_element), get_aggregate_children(step_element)
+    )
+
+
+def get_spatial_children(step_element: entity_instance) -> Generator[entity_instance]:
+    spatial_relations = cast(
+        Iterable[entity_instance] | None,
+        getattr(step_element, "ContainsElements", None),
+    )
+    if spatial_relations is not None:
+        for relation in spatial_relations:
+            yield from cast(Iterable[entity_instance], relation.RelatedElements)
+
+
+def get_aggregate_children(step_element: entity_instance) -> Generator[entity_instance]:
+    aggregate_relations = cast(
+        Iterable[entity_instance] | None,
+        getattr(step_element, "IsDecomposedBy", None),
+    )
+    if aggregate_relations is not None:
+        for relation in aggregate_relations:
+            yield from cast(Iterable[entity_instance], relation.RelatedObjects)

src/speckleifc/importer.py

@@ -0,0 +1,156 @@
+import time
+from dataclasses import dataclass, field
+from typing import cast
+
+from ifcopenshell.entity_instance import entity_instance
+from ifcopenshell.geom import file
+from ifcopenshell.ifcopenshell_wrapper import TriangulationElement
+
+from speckleifc.converter.data_object_converter import data_object_to_speckle
+from speckleifc.converter.geometry_converter import geometry_to_speckle
+from speckleifc.converter.project_converter import project_to_speckle
+from speckleifc.converter.spatial_element_converter import spatial_element_to_speckle
+from speckleifc.ifc_geometry_processing import create_geometry_iterator
+from speckleifc.ifc_openshell_helpers import get_children
+from speckleifc.level_proxy_manager import LevelProxyManager
+from speckleifc.render_material_proxy_manager import RenderMaterialProxyManager
+from specklepy.logging.exceptions import SpeckleException
+from specklepy.objects import Base
+from specklepy.objects.data_objects import DataObject
+
+
+@dataclass
+class ImportJob:
+    ifc_file: file
+    cached_display_values: dict[int, list[Base]] = field(default_factory=dict)  # noqa: F821
+    _render_material_manager: RenderMaterialProxyManager = field(
+        default_factory=lambda: RenderMaterialProxyManager()
+    )
+    _level_proxy_manager: LevelProxyManager = field(
+        default_factory=lambda: LevelProxyManager()
+    )
+    geometries_count: int = 0
+    geometries_used: int = 0
+    _current_storey_data_object: DataObject | None = field(default=None, init=False)
+
+    def convert_element(self, step_element: entity_instance) -> Base:
+        try:
+            return self._convert_element(step_element)
+        except SpeckleException:
+            raise
+        except Exception as ex:
+            raise SpeckleException(
+                f"Failed to convert {step_element.is_a()} #{step_element.id()}"
+            ) from ex
+
+    def _convert_element(self, step_element: entity_instance) -> Base:
+        # Track current storey context and store for level proxies
+        previous_storey_data_object = self._current_storey_data_object
+        if step_element.is_a("IfcBuildingStorey"):
+            # Convert the building storey to a DataObject for the level proxy
+            storey_display_value = self.cached_display_values.get(step_element.id(), [])
+            self._current_storey_data_object = data_object_to_speckle(
+                storey_display_value, step_element, []
+            )
+
+        children = self._convert_children(step_element)
+        id = step_element.id()
+        display_value = self.cached_display_values.get(id, [])
+
+        if display_value:
+            self.geometries_used += 1
+
+        # Extract current storey name from DataObject if available
+        current_storey_name = (
+            self._current_storey_data_object.name
+            if self._current_storey_data_object
+            else None
+        )
+
+        if step_element.is_a("IfcProject"):
+            result = project_to_speckle(step_element, children)
+        elif step_element.is_a("IfcSpatialStructureElement"):
+            result = spatial_element_to_speckle(
+                display_value, step_element, children, current_storey_name
+            )
+        else:
+            result = data_object_to_speckle(
+                display_value, step_element, children, current_storey_name
+            )
+            # Associate non-spatial elements with current storey for level proxies
+            if self._current_storey_data_object is not None and result.applicationId:
+                self._level_proxy_manager.add_element_level_mapping(
+                    self._current_storey_data_object, result.applicationId
+                )
+
+        # Restore previous storey context
+        self._current_storey_data_object = previous_storey_data_object
+        return result
+
+    def _convert_children(self, step_element: entity_instance) -> list[Base]:
+        return [
+            self.convert_element(i)
+            for i in get_children(step_element)
+            if self._should_convert(i)
+        ]
+
+    @staticmethod
+    def _should_convert(step_element: entity_instance) -> bool:
+        # We only consider IfcRoot objects convertible
+        # This is the super class for root level entities that have a GUID...
+        # This will ignore some types like IfcGridAxis
+        s = step_element.is_a("IfcRoot")
+        if not s:
+            print(
+                f"Skipping #{step_element.id()} because it's type ({step_element.is_a()}) it not an IfcRoot"  # noqa: E501
+            )
+        return s
+
+    def convert(self) -> Base:
+        start = time.time()
+        self.pre_process_geometry()
+        print(f"Geometry conversion complete after {(time.time() - start) * 1000}ms")
+        print(f"Created {self.geometries_count} geometries")
+
+        start = time.time()
+        root = self._convert_project_tree()
+        print(f"Object tree conversion complete after {(time.time() - start) * 1000}ms")
+        print(f"Used {self.geometries_used} geometries")
+        return root
+
+    def pre_process_geometry(self) -> None:
+        iterator = create_geometry_iterator(self.ifc_file)
+        if not iterator.initialize():
+            raise SpeckleException("Failed to find any geometry in file")
+        self.geometries_count = 0
+        while True:
+            shape = cast(TriangulationElement, iterator.get())
+            self.geometries_count += 1
+            id = cast(int, shape.id)
+
+            try:
+                display_value = geometry_to_speckle(
+                    shape, self._render_material_manager
+                )
+                self.cached_display_values[id] = display_value
+            except Exception as ex:
+                raise SpeckleException(
+                    f"Failed to convert geometry with id: {id}"
+                ) from ex
+            if not iterator.next():
+                break
+
+    def _convert_project_tree(self) -> Base:
+        projects = self.ifc_file.by_type("IfcProject", False)
+        if len(projects) != 1:
+            raise SpeckleException("Expected exactly one IfcProject in file")
+        project = projects[0]
+
+        tree = self.convert_element(project)
+        tree["renderMaterialProxies"] = list(
+            self._render_material_manager.render_material_proxies.values()
+        )
+        tree["levelProxies"] = list(self._level_proxy_manager.level_proxies.values())
+        tree["version"] = 3
+
+        return tree

src/speckleifc/level_proxy_manager.py

@@ -0,0 +1,27 @@
+from specklepy.objects.data_objects import DataObject
+from specklepy.objects.proxies import LevelProxy
+
+
+class LevelProxyManager:
+    def __init__(self):
+        self._level_proxies: dict[str, LevelProxy] = {}
+
+    @property
+    def level_proxies(self):
+        return self._level_proxies
+
+    def add_element_level_mapping(
+        self, level_data_object: DataObject, element_application_id: str
+    ) -> None:
+        level_id = level_data_object.applicationId
+        assert level_id is not None
+
+        proxy = self._level_proxies.get(level_id, None)
+        if proxy is not None:
+            proxy.objects.append(element_application_id)
+        else:
+            self._level_proxies[level_id] = LevelProxy(
+                objects=[element_application_id],
+                value=level_data_object,
+                applicationId=level_id,
+            )

src/speckleifc/licenses/IfcOpenShell-GPL-3.0.txt

@@ -0,0 +1,621 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS

src/speckleifc/licenses/IfcOpenShell-LGPL-3.0.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

src/speckleifc/licenses/README.md

@@ -0,0 +1,30 @@
+# Third-Party Licenses
+
+This directory contains license files for third-party dependencies used by specklepy.
+
+## IfcOpenShell
+
+IfcOpenShell is an optional dependency available through the `speckleifc` extra:
+
+```bash
+pip install specklepy[speckleifc]
+```
+
+IfcOpenShell is dual-licensed under:
+
+- **LGPL-3.0** (`IfcOpenShell-LGPL-3.0.txt`) - GNU Lesser General Public License v3.0
+- **GPL-3.0** (`IfcOpenShell-GPL-3.0.txt`) - GNU General Public License v3.0
+
+### About IfcOpenShell
+
+IfcOpenShell is an open source software library for working with Industry Foundation Classes (IFC). It provides complete parsing support for IFC2x3 TC1, IFC4 Add2 TC1, IFC4x1, IFC4x2, and IFC4x3 Add2.
+
+- **Project**: https://github.com/IfcOpenShell/IfcOpenShell
+- **Documentation**: https://docs.ifcopenshell.org/
+- **License**: LGPL-3.0-or-later, GPL-3.0-or-later
+
+When using specklepy with IfcOpenShell, you must comply with the terms of these licenses.
+
+## License Compatibility
+
+specklepy is licensed under Apache-2.0, which is compatible with LGPL-3.0 for dynamic linking scenarios (which is how IfcOpenShell is used as an optional dependency).

src/speckleifc/main.py

@@ -0,0 +1,61 @@
+import time
+
+from speckleifc.ifc_geometry_processing import open_ifc
+from speckleifc.importer import ImportJob
+from specklepy.core.api.client import SpeckleClient
+from specklepy.core.api.inputs.version_inputs import CreateVersionInput
+from specklepy.core.api.models.current import Project, Version
+from specklepy.core.api.operations import send
+from specklepy.logging import metrics
+from specklepy.transports.server import ServerTransport
+
+
+def open_and_convert_file(
+    file_path: str,
+    project: Project,
+    version_message: str | None,
+    model_id: str,
+    client: SpeckleClient,
+) -> Version:
+    start = time.time()
+    very_start = start
+
+    account = client.account
+    server_url = account.serverInfo.url
+    assert server_url
+    remote_transport = ServerTransport(project.id, account=account)
+
+    ifc_file = open_ifc(file_path)  # pyright: ignore[reportUnknownVariableType]
+
+    import_job = ImportJob(ifc_file)  # pyright: ignore[reportUnknownArgumentType]
+    data = import_job.convert()
+
+    print(f"File conversion complete after {(time.time() - start) * 1000}ms")
+
+    start = time.time()
+
+    root_id = send(data, transports=[remote_transport], use_default_cache=False)
+    print(f"Sending to speckle complete after: {(time.time() - start) * 1000}ms")
+
+    start = time.time()
+
+    create_version = CreateVersionInput(
+        object_id=root_id,
+        model_id=model_id,
+        project_id=project.id,
+        message=version_message,
+        source_application="ifc",
+    )
+    version = client.version.create(create_version)
+    end = time.time()
+    print(f"Version committed after: {(end - start) * 1000}ms")
+
+    print(f"Total time (to commit): {(end - very_start) * 1000}ms")
+    del ifc_file
+
+    custom_properties = {"ui": "dui3", "actionSource": "import"}
+    if project.workspace_id:
+        custom_properties["workspace_id"] = project.workspace_id
+    metrics.track(metrics.SEND, account, custom_properties, send_sync=True)
+
+    return version

src/speckleifc/property_extraction.py

@@ -0,0 +1,197 @@
+import math
+from typing import Any, Tuple
+
+from ifcopenshell.entity_instance import entity_instance
+from ifcopenshell.util.element import get_type
+from ifcopenshell.util.unit import get_full_unit_name, get_project_unit
+
+UNIT_MAPPING = {
+    "IfcQuantityLength": "LENGTHUNIT",
+    "IfcQuantityArea": "AREAUNIT",
+    "IfcQuantityVolume": "VOLUMEUNIT",
+    "IfcQuantityCount": None,  # Count quantities have no units
+    "IfcQuantityWeight": "MASSUNIT",
+    "IfcQuantityTime": "TIMEUNIT",
+}
+
+
+def extract_properties(element: entity_instance) -> dict[str, object]:
+    (psets, qtos) = _get_ifc_object_properties(element)
+
+    properties: dict[str, object] = {
+        "Attributes": _get_attributes(element),
+        "Property Sets": psets,
+    }
+
+    if qtos:
+        properties["Quantities"] = qtos
+
+    if (ifc_type := get_type(element)) is not None:
+        properties["Element Type Property Sets"] = _get_ifc_element_type_properties(
+            ifc_type,
+        )
+        properties["Element Type Attributes"] = _get_attributes(
+            ifc_type,
+        )
+
+    return properties
+
+
+def _get_attributes(element: entity_instance) -> dict[str, object]:
+    return element.get_info(True, False, scalar_only=True)
+
+
+def _get_ifc_element_type_properties(element: entity_instance) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for definition in element.HasPropertySets or []:
+        if not definition.is_a("IfcPropertySet"):
+            continue
+
+        result[definition.Name] = _get_properties(definition.HasProperties)
+    return result
+
+
+def _get_ifc_object_properties(
+    element: entity_instance,
+) -> Tuple[dict[str, object], dict[str, object]]:
+    psets: dict[str, object] = {}
+    qtos: dict[str, object] = {}
+
+    for rel in getattr(element, "IsDefinedBy", []):
+        if not rel.is_a("IfcRelDefinesByProperties"):
+            continue
+
+        definition: entity_instance | None = rel.RelatingPropertyDefinition
+        if not definition:
+            continue
+
+        try:
+            if definition.is_a("IfcPropertySet"):
+                set_name = definition.Name
+                properties = _get_properties(definition.HasProperties)
+
+                if properties:
+                    psets[set_name] = properties
+
+            elif definition.is_a("IfcElementQuantity"):
+                quantities_data = _get_quantities(definition.Quantities, element)
+                if not quantities_data:
+                    continue
+                quantities_data["id"] = definition.id()
+                qtos[definition.Name] = quantities_data
+
+        except (KeyError, AttributeError):
+            # If entity access fails, skip this quantity set
+            print(f"Skipping {definition}")
+            continue
+
+    return (psets, qtos)
+
+
+def _get_properties(properties: entity_instance) -> dict[str, Any]:
+    """
+    There already exists a canonical way to get properties
+    `ifcopenshell.util.element.get_properties` but it's very verbose
+    and we don't want to bloat our selves with supporting complex property types
+
+    This is a slimmed down version, only supporting a couple of property types
+    """
+    result: dict[str, Any] = {}
+
+    for prop in properties:
+        name = prop.Name
+        if prop.is_a("IfcPropertySingleValue"):
+            val = prop.NominalValue
+            if val is not None:
+                result[name] = val.wrappedValue if hasattr(val, "wrappedValue") else val
+        elif prop.is_a("IfcPropertyListValue"):
+            values = getattr(prop, "ListValues", None)
+            if values:
+                result[name] = [
+                    v.wrappedValue if hasattr(v, "wrappedValue") else v for v in values
+                ]
+        elif prop.is_a("IfcPropertyEnumeratedValue"):
+            values = getattr(prop, "EnumerationValues", None)
+            if values:
+                result[name] = [
+                    v.wrappedValue if hasattr(v, "wrappedValue") else v for v in values
+                ]
+
+        # elif prop.is_a("IfcPropertyTableValue"):
+        #     properties[name] = #not sure if we want to support these...
+    return result
+
+
+def _get_quantities(
+    quantities: list[entity_instance], element: entity_instance
+) -> dict[str, Any]:
+    """Extract quantity values from IfcPhysicalQuantity entities."""
+    results: dict[str, Any] = {}
+    for quantity in quantities or []:
+        quantity_name = quantity.Name
+
+        if quantity.is_a("IfcPhysicalSimpleQuantity"):
+            # Get the quantity value (3rd attribute for simple quantities)
+            value = getattr(quantity, quantity.attribute_name(3))
+            unit_info = _get_unit_info(element, quantity)
+
+            # Server does not consider `NaN` valid json
+            if math.isnan(value):
+                value = None
+
+            if unit_info:
+                # Create structured quantity object with units
+                results[quantity_name] = {
+                    "name": quantity_name,
+                    "value": value,
+                    **unit_info,
+                }
+            else:
+                # No unit info available, keep as simple value with name
+                results[quantity_name] = {"name": quantity_name, "value": value}
+
+        elif quantity.is_a("IfcPhysicalComplexQuantity"):
+            # Handle complex quantities
+            data = {
+                k: v
+                for k, v in quantity.get_info().items()
+                if v is not None and k != "Name"
+            }
+            data["properties"] = _get_quantities(quantity.HasQuantities, element)
+            del data["HasQuantities"]
+            results[quantity_name] = data
+    return results
+
+
+def _get_unit_info(
+    element: entity_instance, quantity: entity_instance
+) -> dict[str, str]:
+    """Get unit information for a quantity."""
+    # Early return for count quantities - they don't have units
+    quantity_type = quantity.is_a()
+    if quantity_type == "IfcQuantityCount":
+        return {}
+
+    unit = getattr(element, "Unit", None)
+    if unit:
+        # Quantity has its own unit
+        unit_name = get_full_unit_name(unit)
+        formatted_unit_name = unit_name.replace("_", " ").title() if unit_name else ""
+        return {"units": formatted_unit_name}
+
+    else:
+        # Fall back to project unit based on quantity type
+        unit_type = UNIT_MAPPING.get(quantity_type)
+        if not unit_type:
+            return {}
+
+        # Get the project unit for this unit type
+        project_unit = get_project_unit(element.file, unit_type, use_cache=True)
+        if not project_unit:
+            return {}
+
+        # Get unit name and format
+        unit_name = get_full_unit_name(project_unit)
+        formatted_unit_name = unit_name.replace("_", " ").title() if unit_name else ""
+
+        return {"units": formatted_unit_name}

src/speckleifc/render_material_proxy_manager.py

@@ -0,0 +1,28 @@
+from specklepy.objects.geometry import Mesh
+from specklepy.objects.other import RenderMaterial
+from specklepy.objects.proxies import RenderMaterialProxy
+
+
+class RenderMaterialProxyManager:
+    def __init__(self):
+        self._render_material_proxies: dict[str, RenderMaterialProxy] = {}
+
+    @property
+    def render_material_proxies(self):
+        return self._render_material_proxies
+
+    def add_mesh_material_mapping(
+        self, render_material: RenderMaterial, mesh: Mesh
+    ) -> None:
+        material_id = render_material.applicationId
+        assert material_id is not None
+        mesh_id = mesh.applicationId
+        assert mesh_id is not None
+
+        proxy = self._render_material_proxies.get(material_id, None)
+        if proxy is not None:
+            proxy.objects.append(mesh_id)
+        else:
+            self._render_material_proxies[material_id] = RenderMaterialProxy(
+                objects=[mesh_id], value=render_material
+            )

src/specklepy/api/client.py

@@ -3,6 +3,7 @@ import contextlib
 from specklepy.api.credentials import Account
 from specklepy.api.resources import (
     ActiveUserResource,
+    FileImportResource,
     ModelResource,
     OtherUserResource,
     ProjectInviteResource,
@@ -118,6 +119,12 @@ class SpeckleClient(CoreSpeckleClient):
             client=self.httpclient,
             server_version=server_version,
         )
+        self.file_import = FileImportResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
         self.subscription = SubscriptionResource(
             account=self.account,
             basepath=self.ws_url,

src/specklepy/api/credentials.py

@@ -1,5 +1,3 @@
-from typing import List, Optional
-
 # following imports seem to be unnecessary, but they need to stay
 # to not break the scripts using these functions as non-core
 from specklepy.core.api.credentials import (  # noqa: F401
@@ -14,7 +12,7 @@ from specklepy.core.api.credentials import get_local_accounts as core_get_local_
 from specklepy.logging import metrics
 
 
-def get_local_accounts(base_path: Optional[str] = None) -> List[Account]:
+def get_local_accounts(base_path: str | None = None) -> list[Account]:
     """Gets all the accounts present in this environment
 
     Arguments:
@@ -38,7 +36,7 @@ def get_local_accounts(base_path: Optional[str] = None) -> List[Account]:
     return accounts
 
 
-def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
+def get_default_account(base_path: str | None = None) -> Account | None:
     """
     Gets this environment's default account if any. If there is no default,
     the first found will be returned and set as default.
@@ -61,7 +59,7 @@ def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
     return default
 
 
-def get_account_from_token(token: str, server_url: str = None) -> Account:
+def get_account_from_token(token: str, server_url: str | None = None) -> Account:
     """Gets the local account for the token if it exists
     Arguments:
         token {str} -- the api token

src/specklepy/api/resources/__init__.py

@@ -1,4 +1,5 @@
 from specklepy.api.resources.current.active_user_resource import ActiveUserResource
+from specklepy.api.resources.current.file_import_resource import FileImportResource
 from specklepy.api.resources.current.model_resource import ModelResource
 from specklepy.api.resources.current.other_user_resource import OtherUserResource
 from specklepy.api.resources.current.project_invite_resource import (
@@ -11,6 +12,7 @@ from specklepy.api.resources.current.version_resource import VersionResource
 from specklepy.api.resources.current.workspace_resource import WorkspaceResource
 
 __all__ = [
+    "FileImportResource",
     "ActiveUserResource",
     "ModelResource",
     "OtherUserResource",

src/specklepy/api/resources/current/active_user_resource.py

@@ -11,7 +11,12 @@ from specklepy.core.api.models import (
     ResourceCollection,
     User,
 )
-from specklepy.core.api.models.current import PermissionCheckResult, Workspace
+from specklepy.core.api.models.current import (
+    LimitedWorkspace,
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
 from specklepy.core.api.resources import ActiveUserResource as CoreResource
 from specklepy.logging import metrics
 
@@ -51,6 +56,22 @@ class ActiveUserResource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Active User Get Projects"})
         return super().get_projects(limit=limit, cursor=cursor, filter=filter)
 
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Active User Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            limit=limit, cursor=cursor, filter=filter
+        )
+
     def get_project_invites(self) -> List[PendingStreamCollaborator]:
         metrics.track(
             metrics.SDK, self.account, {"name": "Active User Get Project Invites"}
@@ -74,7 +95,7 @@ class ActiveUserResource(CoreResource):
         metrics.track(metrics.SDK, self.account, {"name": "Active User Get Workspaces"})
         return super().get_workspaces(limit, cursor, filter)
 
-    def get_active_workspace(self) -> Optional[Workspace]:
+    def get_active_workspace(self) -> Optional[LimitedWorkspace]:
         metrics.track(
             metrics.SDK, self.account, {"name": "Active User Get Active Workspace"}
         )

src/specklepy/api/resources/current/file_import_resource.py

@@ -0,0 +1,87 @@
+from pathlib import Path
+
+from typing_extensions import override
+
+from specklepy.core.api.inputs import (
+    FinishFileImportInput,
+    GenerateFileUploadUrlInput,
+    StartFileImportInput,
+)
+from specklepy.core.api.models import FileImport, FileUploadUrl
+from specklepy.core.api.models.current import ResourceCollection
+from specklepy.core.api.resources import FileImportResource as CoreResource
+from specklepy.core.api.resources.current.file_import_resource import UploadFileResponse
+from specklepy.logging import metrics
+
+
+class FileImportResource(CoreResource):
+    """API Access class for projects"""
+
+    def __init__(self, account, basepath, client, server_version) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+        )
+
+    @override
+    def start_file_import(self, input: StartFileImportInput) -> FileImport:
+        metrics.track(metrics.SDK, self.account, {"name": "File Import Start"})
+        return super().start_file_import(input)
+
+    @override
+    def generate_upload_url(self, input: GenerateFileUploadUrlInput) -> FileUploadUrl:
+        """
+        Get a file upload url from the Speckle server.
+
+        This method asks the server to create a pre-signed S3 url,
+        which can be used as a short term authenticated route,
+        to put a file to the server.
+        """
+        metrics.track(
+            metrics.SDK, self.account, {"name": "File Import Generate Upload Url"}
+        )
+        return super().generate_upload_url(input)
+
+    @override
+    def upload_file(self, file: Path, url: str) -> UploadFileResponse:
+        """
+        Uploads a file to the given S3 url.
+
+        This method should be used together with the generate_upload_url method,
+        which generates a pre-signed S3 url, that can be used to upload the file to.
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "File Import Upload File"})
+        return super().upload_file(file, url)
+
+    @override
+    def download_file(self, project_id: str, file_id: str, target_file: Path) -> Path:
+        """Download a file blob attached to the project, to the target path."""
+        metrics.track(metrics.SDK, self.account, {"name": "File Import Download File"})
+        return super().download_file(project_id, file_id, target_file)
+
+    @override
+    def finish_file_import_job(self, input: FinishFileImportInput) -> bool:
+        """
+        This is mostly an internal api, that marks a file import job finished.
+
+        Only use this if you are writing a file importer, that is responsible for
+        processing file import jobs.
+        """
+        metrics.track(metrics.SDK, self.account, {"name": "File Import Finish Job"})
+        return super().finish_file_import_job(input)
+
+    @override
+    def get_model_file_import_jobs(
+        self,
+        *,
+        project_id: str,
+        model_id: str,
+        limit: int = 25,
+        cursor: str | None = None,
+    ) -> ResourceCollection[FileImport]:
+        metrics.track(metrics.SDK, self.account, {"name": "File Import Get Model Jobs"})
+        return super().get_model_file_import_jobs(
+            project_id=project_id, model_id=model_id, limit=limit, cursor=cursor
+        )

src/specklepy/api/resources/current/project_resource.py

@@ -7,7 +7,11 @@ from specklepy.core.api.inputs.project_inputs import (
     ProjectUpdateRoleInput,
     WorkspaceProjectCreateInput,
 )
-from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
 from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.core.api.resources import ProjectResource as CoreResource
 from specklepy.logging import metrics

src/specklepy/api/resources/current/workspace_resource.py

@@ -1,7 +1,12 @@
 from typing import Optional
 
 from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
-from specklepy.core.api.models.current import Project, ResourceCollection, Workspace
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
 from specklepy.core.api.resources import WorkspaceResource as CoreResource
 from specklepy.logging import metrics
 
@@ -30,3 +35,19 @@ class WorkspaceResource(CoreResource):
     ) -> ResourceCollection[Project]:
         metrics.track(metrics.SDK, self.account, {"name": "Workspace Get Projects"})
         return super().get_projects(workspace_id, limit, cursor, filter)
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        metrics.track(
+            metrics.SDK,
+            self.account,
+            {"name": "Workspace Get Projects With Permissions"},
+        )
+        return super().get_projects_with_permissions(
+            workspace_id, limit, cursor, filter
+        )

src/specklepy/core/api/client.py

@@ -11,6 +11,7 @@ from gql.transport.websockets import WebsocketsTransport
 from specklepy.core.api.credentials import Account
 from specklepy.core.api.resources import (
     ActiveUserResource,
+    FileImportResource,
     ModelResource,
     OtherUserResource,
     ProjectInviteResource,
@@ -130,6 +131,19 @@ class SpeckleClient:
         self.account = Account.from_token(token, self.url)
         self._set_up_client()
 
+        userData = self.active_user.get()
+
+        # None if the token lacked the profile:read scope or if it was None
+        if userData:
+            self.account.userInfo.id = userData.id
+            self.account.userInfo.email = userData.email
+            self.account.userInfo.name = userData.name
+            self.account.userInfo.company = userData.company
+            self.account.userInfo.avatar = userData.avatar
+
+        self.account.serverInfo = self.server.get()
+        self.account.serverInfo.url = self.url
+
     def authenticate_with_account(self, account: Account) -> None:
         """Authenticate the client using an Account object
         The account is saved in the client object and a synchronous GraphQL
@@ -142,6 +156,21 @@ class SpeckleClient:
         self.account = account
         self._set_up_client()
 
+        try:
+            _ = self.active_user.get()
+        except SpeckleException as ex:
+            if isinstance(ex.exception, TransportServerError):
+                if ex.exception.code == 403:
+                    warn(
+                        SpeckleWarning(
+                            "Possibly invalid token - could not authenticate "
+                            f"Speckle Client for server {self.url}"
+                        ),
+                        stacklevel=2,
+                    )
+                else:
+                    raise ex
+
     def _set_up_client(self) -> None:
         headers = {
             "Authorization": f"Bearer {self.account.token}",
@@ -161,21 +190,6 @@ class SpeckleClient:
 
         self._init_resources()
 
-        try:
-            _ = self.active_user.get()
-        except SpeckleException as ex:
-            if isinstance(ex.exception, TransportServerError):
-                if ex.exception.code == 403:
-                    warn(
-                        SpeckleWarning(
-                            "Possibly invalid token - could not authenticate "
-                            f"Speckle Client for server {self.url}"
-                        ),
-                        stacklevel=2,
-                    )
-                else:
-                    raise ex
-
     def execute_query(self, query: str) -> Dict:
         return self.httpclient.execute(query)
 
@@ -230,6 +244,12 @@ class SpeckleClient:
             client=self.httpclient,
             server_version=server_version,
         )
+        self.file_import = FileImportResource(
+            account=self.account,
+            basepath=self.url,
+            client=self.httpclient,
+            server_version=server_version,
+        )
         self.subscription = SubscriptionResource(
             account=self.account,
             basepath=self.ws_url,

src/specklepy/core/api/connector_versions.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+from typing import List
+
+import httpx
+from pydantic import AliasGenerator, BaseModel, ConfigDict, HttpUrl
+from pydantic.alias_generators import to_pascal
+
+
+class ConnectorFeedBaseModel(BaseModel):
+    """
+    Parent class for all Connector Feed Object Model classes
+    Sets-up a pydantic config to serialize properties using a pascal case alias
+    """
+
+    model_config = ConfigDict(
+        alias_generator=AliasGenerator(
+            validation_alias=to_pascal,
+        ),
+        populate_by_name=True,
+    )
+
+
+class ConnectorVersion(ConnectorFeedBaseModel):
+    number: str
+    url: HttpUrl
+    os: int  # this is an enum, it's properly defined in the old v2 SDK (used by Speckle.Manager.Feed)  # noqa: E501
+    architecture: int  # These are enums, they are properly defined in the old v2 SDK (used by Speckle.Manager.Feed) # noqa: E501
+    date: datetime
+    prerelease: bool
+
+
+class ConnectorVersions(ConnectorFeedBaseModel):
+    versions: List[ConnectorVersion]
+
+
+def get_latest_version(host_app_slug: str, allow_pre_release: bool) -> ConnectorVersion:
+    """
+    Fetches the JSON feed for the given connector slug and
+    Returns the latest version by date - Note, it does not consider semvers!
+
+    Arguments:
+        host_app_slug {str} -- the host app slug to query for
+        allow_pre_release {bool} -- if false, only stable releases will be considered
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+        ValueError: The feed contained no connector versions
+    """
+    connector_versions = get_connector_versions(host_app_slug).versions
+    filtered_versions = [
+        v for v in connector_versions if allow_pre_release or not v.prerelease
+    ]
+
+    return max(filtered_versions, key=lambda x: x.date)
+
+
+def get_connector_versions(host_app_slug: str) -> ConnectorVersions:
+    """
+    Fetches the JSON feed for the given slug (v3 feeds only)
+    Raises:
+        HTTPStatusError: if http request failed
+        ValidationError: response was not valid json
+    """
+    url = f"https://releases.speckle.dev/manager2/feeds/{host_app_slug.lower()}-v3.json"
+
+    res = httpx.get(url).raise_for_status()
+
+    feed_data = ConnectorVersions.model_validate_json(res.text)
+
+    return feed_data

src/specklepy/core/api/credentials.py

@@ -1,6 +1,6 @@
 import os
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 from urllib.parse import urlparse
 
 from pydantic import BaseModel, Field  # pylint: disable=no-name-in-module
@@ -12,20 +12,20 @@ from specklepy.transports.sqlite import SQLiteTransport
 
 
 class UserInfo(BaseModel):
-    id: Optional[str] = None
-    name: Optional[str] = None
-    email: Optional[str] = None
-    company: Optional[str] = None
-    avatar: Optional[str] = None
+    id: str | None = None
+    name: str | None = None
+    email: str | None = None
+    company: str | None = None
+    avatar: str | None = None
 
 
 class Account(BaseModel):
     isDefault: bool = False
-    token: Optional[str] = None
-    refreshToken: Optional[str] = None
+    token: str | None = None
+    refreshToken: str | None = None
     serverInfo: ServerInfo = Field(default_factory=ServerInfo)
     userInfo: UserInfo = Field(default_factory=UserInfo)
-    id: Optional[str] = None
+    id: str | None = None
 
     def __repr__(self) -> str:
         return (
@@ -37,13 +37,13 @@ class Account(BaseModel):
         return self.__repr__()
 
     @classmethod
-    def from_token(cls, token: str, server_url: str = None):
+    def from_token(cls, token: str, server_url: str | None = None):
         acct = cls(token=token)
         acct.serverInfo.url = server_url
         return acct
 
 
-def get_local_accounts(base_path: Optional[str] = None) -> List[Account]:
+def get_local_accounts(base_path: str | None = None) -> List[Account]:
     """Gets all the accounts present in this environment
 
     Arguments:
@@ -93,7 +93,7 @@ def get_local_accounts(base_path: Optional[str] = None) -> List[Account]:
     return accounts
 
 
-def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
+def get_default_account(base_path: str | None = None) -> Account | None:
     """
     Gets this environment's default account if any. If there is no default,
     the first found will be returned and set as default.
@@ -116,7 +116,7 @@ def get_default_account(base_path: Optional[str] = None) -> Optional[Account]:
     return default
 
 
-def get_account_from_token(token: str, server_url: str = None) -> Account:
+def get_account_from_token(token: str, server_url: str | None = None) -> Account:
     """Gets the local account for the token if it exists
     Arguments:
         token {str} -- the api token

src/specklepy/core/api/enums.py

@@ -10,9 +10,6 @@ class ProjectVisibility(str, Enum):
     WORKSPACE = "WORKSPACE"
 
 
-foo = ProjectVisibility.PRIVATE
-
-
 class UserProjectsUpdatedMessageType(str, Enum):
     ADDED = "ADDED"
     REMOVED = "REMOVED"

src/specklepy/core/api/inputs/__init__.py

@@ -1,3 +1,10 @@
+from specklepy.core.api.inputs.file_import_inputs import (
+    FileImportErrorInput,
+    FileImportSuccessInput,
+    FinishFileImportInput,
+    GenerateFileUploadUrlInput,
+    StartFileImportInput,
+)
 from specklepy.core.api.inputs.model_inputs import (
     CreateModelInput,
     DeleteModelInput,
@@ -22,6 +29,11 @@ from specklepy.core.api.inputs.version_inputs import (
 )
 
 __all__ = [
+    "FileImportErrorInput",
+    "FileImportSuccessInput",
+    "FinishFileImportInput",
+    "StartFileImportInput",
+    "GenerateFileUploadUrlInput",
     "CreateModelInput",
     "DeleteModelInput",
     "UpdateModelInput",

src/specklepy/core/api/inputs/file_import_inputs.py

@@ -0,0 +1,44 @@
+from typing import Literal
+
+from pydantic import Field
+
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+
+
+class GenerateFileUploadUrlInput(GraphQLBaseModel):
+    project_id: str
+    file_name: str
+
+
+class StartFileImportInput(GraphQLBaseModel):
+    project_id: str
+    model_id: str
+    file_id: str
+    etag: str
+
+
+class FileImportResult(GraphQLBaseModel):
+    duration_seconds: float
+    download_duration_seconds: float
+    parse_duration_seconds: float
+    parser: str
+    version_id: str | None
+
+
+class FileImportInputBase(GraphQLBaseModel):
+    project_id: str
+    job_id: str
+    warnings: list[str] = Field(default_factory=list)
+    result: FileImportResult
+
+
+class FileImportSuccessInput(FileImportInputBase):
+    status: Literal["success"] = "success"
+
+
+class FileImportErrorInput(FileImportInputBase):
+    status: Literal["error"] = "error"
+    reason: str
+
+
+FinishFileImportInput = FileImportSuccessInput | FileImportErrorInput

src/specklepy/core/api/models/__init__.py

@@ -1,5 +1,7 @@
 from specklepy.core.api.models.current import (
     AuthStrategy,
+    FileImport,
+    FileUploadUrl,
     LimitedUser,
     Model,
     ModelWithVersions,
@@ -8,6 +10,7 @@ from specklepy.core.api.models.current import (
     ProjectCollaborator,
     ProjectCommentCollection,
     ProjectWithModels,
+    ProjectWithPermissions,
     ProjectWithTeam,
     ResourceCollection,
     ServerConfiguration,
@@ -39,6 +42,7 @@ __all__ = [
     "ModelWithVersions",
     "Project",
     "ProjectWithModels",
+    "ProjectWithPermissions",
     "ProjectWithTeam",
     "ProjectCommentCollection",
     "UserSearchResultCollection",
@@ -46,4 +50,6 @@ __all__ = [
     "ProjectModelsUpdatedMessage",
     "ProjectUpdatedMessage",
     "ProjectVersionsUpdatedMessage",
+    "FileImport",
+    "FileUploadUrl",
 ]

src/specklepy/core/api/models/current.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Generic, List, Optional, TypeVar
+from typing import Generic, List, TypeVar
 
 from specklepy.core.api.enums import ProjectVisibility
 from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
@@ -10,13 +10,13 @@ T = TypeVar("T")
 
 class User(GraphQLBaseModel):
     id: str
-    email: Optional[str] = None
+    email: str | None = None
     name: str
-    bio: Optional[str] = None
-    company: Optional[str] = None
-    avatar: Optional[str] = None
-    verified: Optional[bool] = None
-    role: Optional[str] = None
+    bio: str | None = None
+    company: str | None = None
+    avatar: str | None = None
+    verified: bool | None = None
+    role: str | None = None
 
     def __repr__(self):
         return (
@@ -31,16 +31,16 @@ class User(GraphQLBaseModel):
 class ResourceCollection(GraphQLBaseModel, Generic[T]):
     total_count: int
     items: List[T]
-    cursor: Optional[str] = None
+    cursor: str | None = None
 
 
 class ServerMigration(GraphQLBaseModel):
-    moved_from: Optional[str]
-    moved_to: Optional[str]
+    moved_from: str | None
+    moved_to: str | None
 
 
 class AuthStrategy(GraphQLBaseModel):
-    color: Optional[str]
+    color: str | None
     icon: str
     id: str
     name: str
@@ -60,17 +60,17 @@ class ServerWorkspacesInfo(GraphQLBaseModel):
 # Keeping this one all Optionals at the minute,
 #  because its used both as a deserialization model for GQL and Account Management
 class ServerInfo(GraphQLBaseModel):
-    name: Optional[str] = None
-    company: Optional[str] = None
-    url: Optional[str] = None
-    admin_contact: Optional[str] = None
-    description: Optional[str] = None
-    canonical_url: Optional[str] = None
-    scopes: Optional[List[dict]] = None
-    auth_strategies: Optional[List[dict]] = None
-    version: Optional[str] = None
-    migration: Optional[ServerMigration] = None
-    workspaces: Optional[ServerWorkspacesInfo] = None
+    name: str | None = None
+    company: str | None = None
+    url: str | None = None
+    admin_contact: str | None = None
+    description: str | None = None
+    canonical_url: str | None = None
+    scopes: List[dict] | None = None
+    auth_strategies: List[dict] | None = None
+    version: str | None = None
+    migration: ServerMigration | None = None
+    workspaces: ServerWorkspacesInfo | None = None
     # TODO separate gql model from account management model
 
 
@@ -79,11 +79,11 @@ class LimitedUser(GraphQLBaseModel):
 
     id: str
     name: str
-    bio: Optional[str]
-    company: Optional[str]
-    avatar: Optional[str]
-    verified: Optional[bool]
-    role: Optional[str]
+    bio: str | None
+    company: str | None
+    avatar: str | None
+    verified: bool | None
+    role: str | None
 
     def __repr__(self):
         return (
@@ -99,15 +99,15 @@ class LimitedUser(GraphQLBaseModel):
 class PendingStreamCollaborator(GraphQLBaseModel):
     id: str
     invite_id: str
-    stream_id: Optional[str] = None
+    stream_id: str | None = None
     projectId: str
-    stream_name: Optional[str] = None
+    stream_name: str | None = None
     project_name: str
     title: str
     role: str
     invited_by: LimitedUser
-    user: Optional[LimitedUser] = None
-    token: Optional[str]
+    user: LimitedUser | None = None
+    token: str | None
 
     def __repr__(self):
         return (
@@ -127,24 +127,24 @@ class ProjectCollaborator(GraphQLBaseModel):
 
 
 class Version(GraphQLBaseModel):
-    author_user: Optional[LimitedUser]
+    author_user: LimitedUser | None
     created_at: datetime
     id: str
-    message: Optional[str]
+    message: str | None
     preview_url: str
-    referenced_object: Optional[str]
+    referenced_object: str | None
     """Maybe null if workspaces version history limit has been exceeded"""
-    source_application: Optional[str]
+    source_application: str | None
 
 
 class Model(GraphQLBaseModel):
-    author: Optional[LimitedUser]
+    author: LimitedUser | None
     created_at: datetime
-    description: Optional[str]
+    description: str | None
     display_name: str
     id: str
     name: str
-    preview_url: Optional[str]
+    preview_url: str | None
     updated_at: datetime
 
 
@@ -162,20 +162,24 @@ class ProjectPermissionChecks(GraphQLBaseModel):
 class Project(GraphQLBaseModel):
     allow_public_comments: bool
     created_at: datetime
-    description: Optional[str]
+    description: str | None
     id: str
     name: str
-    role: Optional[str]
+    role: str | None
     source_apps: List[str]
     updated_at: datetime
     visibility: ProjectVisibility
-    workspace_id: Optional[str]
+    workspace_id: str | None
 
 
 class ProjectWithModels(Project):
     models: ResourceCollection[Model]
 
 
+class ProjectWithPermissions(Project):
+    permissions: ProjectPermissionChecks
+
+
 class ProjectWithTeam(Project):
     invited_team: List[PendingStreamCollaborator]
     team: List[ProjectCollaborator]
@@ -187,7 +191,7 @@ class ProjectCommentCollection(ResourceCollection[T], Generic[T]):
 
 class UserSearchResultCollection(GraphQLBaseModel):
     items: List[LimitedUser]
-    cursor: Optional[str] = None
+    cursor: str | None = None
 
 
 class PermissionCheckResult(GraphQLBaseModel):
@@ -209,15 +213,34 @@ class WorkspaceCreationState(GraphQLBaseModel):
     completed: bool
 
 
-class Workspace(GraphQLBaseModel):
+class LimitedWorkspace(GraphQLBaseModel):
     id: str
     name: str
-    role: Optional[str]
+    role: str | None
     slug: str
-    logo: Optional[str]
+    logo: str | None
+    description: str | None
+
+
+class Workspace(LimitedWorkspace):
     created_at: datetime
     updated_at: datetime
     read_only: bool
-    description: Optional[str]
-    creation_state: Optional[WorkspaceCreationState]
+    creation_state: WorkspaceCreationState | None
     permissions: WorkspacePermissionChecks
+
+
+class FileImport(GraphQLBaseModel):
+    id: str
+    project_id: str
+    converted_version_id: str | None
+    user_id: str
+    converted_status: int
+    converted_message: str | None
+    model_id: str | None
+    updated_at: datetime
+
+
+class FileUploadUrl(GraphQLBaseModel):
+    url: str
+    file_id: str

src/specklepy/core/api/resources/__init__.py

@@ -1,4 +1,5 @@
 from specklepy.core.api.resources.current.active_user_resource import ActiveUserResource
+from specklepy.core.api.resources.current.file_import_resource import FileImportResource
 from specklepy.core.api.resources.current.model_resource import ModelResource
 from specklepy.core.api.resources.current.other_user_resource import OtherUserResource
 from specklepy.core.api.resources.current.project_invite_resource import (
@@ -13,6 +14,7 @@ from specklepy.core.api.resources.current.version_resource import VersionResourc
 from specklepy.core.api.resources.current.workspace_resource import WorkspaceResource
 
 __all__ = [
+    "FileImportResource",
     "ActiveUserResource",
     "ModelResource",
     "OtherUserResource",

src/specklepy/core/api/resources/current/active_user_resource.py

@@ -13,7 +13,12 @@ from specklepy.core.api.models import (
     ResourceCollection,
     User,
 )
-from specklepy.core.api.models.current import PermissionCheckResult, Workspace
+from specklepy.core.api.models.current import (
+    LimitedWorkspace,
+    PermissionCheckResult,
+    ProjectWithPermissions,
+    Workspace,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse
 from specklepy.logging.exceptions import GraphQLException
@@ -291,7 +296,7 @@ class ActiveUserResource(ResourceBase):
 
         return response.data.data
 
-    def get_active_workspace(self) -> Optional[Workspace]:
+    def get_active_workspace(self) -> Optional[LimitedWorkspace]:
         """
         This feature is only available on Workspace enabled servers  (server versions
         >=2.23.17) e.g. app.speckle.systems
@@ -306,29 +311,15 @@ class ActiveUserResource(ResourceBase):
                   role
                   slug
                   logo
-                  createdAt
-                  updatedAt
-                  readOnly
                   description
-                  creationState
-                  {
-                    completed
-                  }
-                  permissions {
-                    canCreateProject {
-                      authorized
-                      code
-                      message
-                    }
-                  }
                 }
               }
             }
-            """  # noqa: E501
+            """
         )
 
         response = self.make_request_and_parse_response(
-            DataResponse[Optional[DataResponse[Optional[Workspace]]]],
+            DataResponse[Optional[DataResponse[Optional[LimitedWorkspace]]]],
             QUERY,
         )
 
@@ -338,3 +329,84 @@ class ActiveUserResource(ResourceBase):
             )
 
         return response.data.data
+
+    def get_projects_with_permissions(
+        self,
+        *,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[UserProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        """
+        Gets the currently active user's projects with their permissions.
+        This is useful for checking what actions can be performed on each project.
+        """
+        QUERY = gql(
+            """
+          query User($limit : Int!, $cursor: String, $filter: UserProjectsFilter) {
+            data:activeUser {
+              data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                totalCount
+                cursor
+                items {
+                    id
+                    name
+                    description
+                    visibility
+                    allowPublicComments
+                    role
+                    createdAt
+                    updatedAt
+                    sourceApps
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                }
+              }
+            }
+          }
+          """
+        )
+
+        variables = {
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        response = self.make_request_and_parse_response(
+            DataResponse[
+                Optional[DataResponse[ResourceCollection[ProjectWithPermissions]]]
+            ],
+            QUERY,
+            variables,
+        )
+
+        if response.data is None:
+            raise GraphQLException(
+                "GraphQL response indicated that the ActiveUser could not be found"
+            )
+
+        return response.data.data

src/specklepy/core/api/resources/current/file_import_resource.py

@@ -0,0 +1,212 @@
+from pathlib import Path
+from typing import Any
+
+import httpx
+from gql import Client, gql
+
+from specklepy.core.api.credentials import Account
+from specklepy.core.api.inputs.file_import_inputs import (
+    FinishFileImportInput,
+    GenerateFileUploadUrlInput,
+    StartFileImportInput,
+)
+from specklepy.core.api.models import FileImport, FileUploadUrl, ResourceCollection
+from specklepy.core.api.models.graphql_base_model import GraphQLBaseModel
+from specklepy.core.api.resource import ResourceBase
+from specklepy.core.api.responses import DataResponse
+from specklepy.logging.exceptions import SpeckleException
+
+
+class UploadFileResponse(GraphQLBaseModel):
+    etag: str
+
+
+class FileImportResource(ResourceBase):
+    """API Access class for project invites"""
+
+    def __init__(
+        self,
+        account: Account,
+        basepath: str,
+        client: Client,
+        server_version: tuple[Any, ...] | None,  # pyright: ignore[reportExplicitAny]
+    ) -> None:
+        super().__init__(
+            account=account,
+            basepath=basepath,
+            client=client,
+            server_version=server_version,
+            name="file-import",
+        )
+
+    def finish_file_import_job(self, input: FinishFileImportInput) -> bool:
+        """
+        This is mostly an internal api, that marks a file import job finished.
+
+        Only use this if you are writing a file importer, that is responsible for
+        processing file import jobs.
+        """
+        QUERY = gql(
+            """
+                mutation FinishFileImport($input: FinishFileImportInput!) {
+                    data:fileUploadMutations {
+                        data:finishFileImport(input: $input)
+                    }
+                }
+            """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[bool]], QUERY, variables
+        ).data.data
+
+    def start_file_import(self, input: StartFileImportInput) -> FileImport:
+        QUERY = gql(
+            """
+            mutation StartFileImport($input: StartFileImportInput!) {
+                data:fileUploadMutations {
+                    data:startFileImport(input: $input) {
+                        id
+                        projectId
+                        convertedVersionId
+                        userId
+                        convertedStatus
+                        convertedMessage
+                        modelId
+                        updatedAt
+                    }
+                }
+            }
+        """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[FileImport]], QUERY, variables
+        ).data.data
+
+    def generate_upload_url(self, input: GenerateFileUploadUrlInput) -> FileUploadUrl:
+        """
+        Get a file upload url from the Speckle server.
+
+        This method asks the server to create a pre-signed S3 url,
+        which can be used as a short term authenticated route,
+        to put a file to the server.
+        """
+        QUERY = gql(
+            """
+            mutation GenerateUploadUrl($input: GenerateFileUploadUrlInput!) {
+                data:fileUploadMutations {
+                    data:generateUploadUrl(input: $input) {
+                        fileId
+                        url
+                    }
+                }
+            }
+        """
+        )
+
+        variables = {
+            "input": input.model_dump(warnings="error", by_alias=True),
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[FileUploadUrl]], QUERY, variables
+        ).data.data
+
+    def upload_file(self, file: Path, url: str) -> UploadFileResponse:
+        """
+        Uploads a file to the given S3 url.
+
+        This method should be used together with the generate_upload_url method,
+        which generates a pre-signed S3 url, that can be used to upload the file to.
+        """
+        with open(file, "rb") as content:
+            response = httpx.put(
+                url,
+                content=content,  # Pass file object directly for streaming
+                headers={
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": str(file.stat().st_size),
+                },
+            ).raise_for_status()
+            etag = response.headers.get("ETag", None)  # pyright: ignore[reportAny]
+            if not etag:
+                raise SpeckleException(
+                    "Response does not have an ETag attached to it,"
+                    + " cannot use this as an upload"
+                )
+            return UploadFileResponse(etag=str(etag))  # pyright: ignore[reportAny]
+
+    def download_file(self, project_id: str, file_id: str, target_file: Path) -> Path:
+        """Download a file blob attached to the project, to the target path."""
+        if not target_file.parent.exists():
+            target_file.parent.mkdir(parents=True)
+        url = f"{self.basepath}/api/stream/{project_id}/blob/{file_id}"
+        with httpx.stream(
+            "GET", url, headers={"Authorization": f"Bearer {self.account.token}"}
+        ) as response:
+            _ = response.raise_for_status()
+            with target_file.open("wb") as f:
+                for chunk in response.iter_bytes(chunk_size=8192):
+                    _ = f.write(chunk)
+        return target_file
+
+    def get_model_file_import_jobs(
+        self,
+        *,
+        project_id: str,
+        model_id: str,
+        limit: int = 25,
+        cursor: str | None = None,
+    ) -> ResourceCollection[FileImport]:
+        QUERY = gql(
+            """
+            query ModelFileImportJobs(
+                $projectId: String!,
+                $modelId: String!,
+                $input: GetModelUploadsInput
+            ) {
+              data:project(id: $projectId) {
+                data:model(id: $modelId) {
+                    data:uploads(input: $input) {
+                        totalCount
+                        cursor
+                        items {
+                            id
+                            projectId
+                            convertedVersionId
+                            userId
+                            convertedStatus
+                            convertedMessage
+                            modelId
+                            updatedAt
+                        }
+                    }
+                }
+              }
+            }
+            """
+        )
+
+        variables = {
+            "projectId": project_id,
+            "modelId": model_id,
+            "input": {
+                "limit": limit,
+                "cursor": cursor,
+            },
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[DataResponse[ResourceCollection[FileImport]]]],
+            QUERY,
+            variables,
+        ).data.data.data

src/specklepy/core/api/resources/current/project_resource.py

@@ -9,7 +9,11 @@ from specklepy.core.api.inputs.project_inputs import (
     ProjectUpdateRoleInput,
     WorkspaceProjectCreateInput,
 )
-from specklepy.core.api.models import Project, ProjectWithModels, ProjectWithTeam
+from specklepy.core.api.models import (
+    Project,
+    ProjectWithModels,
+    ProjectWithTeam,
+)
 from specklepy.core.api.models.current import ProjectPermissionChecks
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse

src/specklepy/core/api/resources/current/workspace_resource.py

@@ -3,7 +3,12 @@ from typing import Optional
 from gql import gql
 
 from specklepy.core.api.inputs.project_inputs import WorksaceProjectsFilter
-from specklepy.core.api.models.current import Project, ResourceCollection, Workspace
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+    Workspace,
+)
 from specklepy.core.api.resource import ResourceBase
 from specklepy.core.api.responses import DataResponse
 
@@ -104,3 +109,72 @@ class WorkspaceResource(ResourceBase):
         return self.make_request_and_parse_response(
             DataResponse[DataResponse[ResourceCollection[Project]]], QUERY, variables
         ).data.data
+
+    def get_projects_with_permissions(
+        self,
+        workspace_id: str,
+        limit: int = 25,
+        cursor: Optional[str] = None,
+        filter: Optional[WorksaceProjectsFilter] = None,
+    ) -> ResourceCollection[ProjectWithPermissions]:
+        QUERY = gql(
+            """
+            query Workspace($workspaceId: String!, $limit: Int!, $cursor: String, $filter: WorkspaceProjectsFilter) {
+              data:workspace(id: $workspaceId) {
+                data:projects(limit: $limit, cursor: $cursor, filter: $filter) {
+                  cursor
+                  items {
+                    allowPublicComments
+                    createdAt
+                    description
+                    id
+                    name
+                    role
+                    sourceApps
+                    updatedAt
+                    visibility
+                    workspaceId
+                    permissions {
+                      canCreateModel {
+                        code
+                        authorized
+                        message
+                      }
+                      canDelete {
+                        code
+                        authorized
+                        message
+                      }
+                      canLoad {
+                        code
+                        authorized
+                        message
+                      }
+                      canPublish {
+                        code
+                        authorized
+                        message
+                      }
+                    }
+                  }
+                  totalCount
+                }
+              }
+            }
+            """  # noqa: E501
+        )
+
+        variables = {
+            "workspaceId": workspace_id,
+            "limit": limit,
+            "cursor": cursor,
+            "filter": filter.model_dump(warnings="error", by_alias=True)
+            if filter
+            else None,
+        }
+
+        return self.make_request_and_parse_response(
+            DataResponse[DataResponse[ResourceCollection[ProjectWithPermissions]]],
+            QUERY,
+            variables,
+        ).data.data

src/specklepy/core/api/wrapper.py

@@ -1,8 +1,6 @@
 from urllib.parse import quote, unquote, urlparse
 from warnings import warn
 
-from gql import gql
-
 from specklepy.core.api.client import SpeckleClient
 from specklepy.core.api.credentials import (
     Account,
@@ -139,27 +137,11 @@ class StreamWrapper:
 
         if use_fe2 is True and self.branch_name is not None:
             self.model_id = self.branch_name
-            # get branch name
-            query = gql(
-                """
-                query Project($project_id: String!, $model_id: String!) {
-                    project(id: $project_id) {
-                        id
-                        model(id: $model_id) {
-                            name
-                        }
-                    }
-                }
-            """
-            )
-            self._client = self.get_client()
-            params = {"project_id": self.stream_id, "model_id": self.model_id}
-            project = self._client.httpclient.execute(query, params)
 
-            try:
-                self.branch_name = project["project"]["model"]["name"]
-            except KeyError as ke:
-                raise SpeckleException("Project model name is not found", ke) from ke
+            self._client = self.get_client()
+            model = self._client.model.get(self.model_id, self.stream_id)
+
+            self.branch_name = model.name
 
         if not self.stream_id:
             raise SpeckleException(
@@ -175,6 +157,10 @@ class StreamWrapper:
         """
         Gets an account object for this server from the local accounts db
         (added via Speckle Manager or a json file)
+
+        WARNING: this function will return ANY account for the server,
+          just because you pass a token in doesn't guarantee it will be used.
+          This whole class could do with a re-design...
         """
         if self._account and self._account.token:
             return self._account

src/specklepy/core/helpers/__init__.py

@@ -1 +1,5 @@
 """Common helpers module for Core."""
+
+from specklepy.core.helpers.random import crypto_random_string
+
+__all__ = ["crypto_random_string"]

src/specklepy/core/helpers/random.py

@@ -0,0 +1,8 @@
+import secrets
+import string
+
+
+def crypto_random_string(length: int) -> str:
+    """Generate a semi crypto random string of a given length."""
+    alphabet = string.ascii_letters + string.digits
+    return "".join(secrets.choice(alphabet) for _ in range(length)).lower()

src/specklepy/core/helpers/speckle_path_provider.py

@@ -88,6 +88,8 @@ def user_application_data_path() -> Path:
                     message="Cannot get appdata path from environment."
                 )
             return Path(app_data_path)
+        if sys.platform.startswith("darwin"):  # macOS
+            return _ensure_folder_exists(Path.home() / "Library", "Application Support")
         else:
             # try getting the standard XDG_DATA_HOME value
             # as that is used as an override
@@ -98,7 +100,7 @@ def user_application_data_path() -> Path:
                 return _ensure_folder_exists(Path.home(), ".config")
     except Exception as ex:
         raise SpeckleException(
-            message="Failed to initialize user application data path.", exception=ex
+            message="Failed to initialize user application data path."
         ) from ex
 
 

src/specklepy/logging/metrics.py

@@ -6,10 +6,12 @@ import platform
 import queue
 import sys
 import threading
-from typing import Optional
+from typing import Any
 
 import requests
 
+from specklepy.core.api.credentials import Account
+
 """
 Anonymous telemetry to help us understand how to make a better Speckle.
 This really helps us to deliver a better open source project and product!
@@ -28,21 +30,6 @@ CONNECTOR = "Connector Action"
 RECEIVE = "Receive"
 SEND = "Send"
 
-# not in use since 2.15
-ACCOUNTS = "Get Local Accounts"
-BRANCH = "Branch Action"
-CLIENT = "Speckle Client"
-COMMIT = "Commit Action"
-DESERIALIZE = "serialization/deserialize"
-INVITE = "Invite Action"
-OTHER_USER = "Other User Action"
-PERMISSION = "Permission Action"
-SERIALIZE = "serialization/serialize"
-SERVER = "Server Action"
-STREAM = "Stream Action"
-STREAM_WRAPPER = "Stream Wrapper"
-USER = "User Action"
-
 
 def disable():
     global TRACK
@@ -54,7 +41,7 @@ def enable():
     TRACK = True
 
 
-def set_host_app(host_app: str, host_app_version: Optional[str] = None):
+def set_host_app(host_app: str, host_app_version: str | None = None):
     global HOST_APP, HOST_APP_VERSION
     HOST_APP = host_app
     HOST_APP_VERSION = host_app_version or HOST_APP_VERSION
@@ -62,45 +49,46 @@ def set_host_app(host_app: str, host_app_version: Optional[str] = None):
 
 def track(
     action: str,
-    account=None,
-    custom_props: Optional[dict] = None,
+    account: Account | None = None,
+    custom_props: dict | None = None,
+    send_sync: bool = False,
 ):
     if not TRACK:
         return
-    try:
-        initialise_tracker(account)
-        event_params = {
-            "event": action,
-            "properties": {
-                "distinct_id": METRICS_TRACKER.last_user,
-                "server_id": METRICS_TRACKER.last_server,
-                "token": METRICS_TRACKER.analytics_token,
-                "hostApp": HOST_APP,
-                "hostAppVersion": HOST_APP_VERSION,
-                "$os": METRICS_TRACKER.platform,
-                "type": "action",
-            },
-        }
-        if custom_props:
-            event_params["properties"].update(custom_props)
 
-        METRICS_TRACKER.queue.put_nowait(event_params)
-    except Exception as ex:
-        # wrapping this whole thing in a try except as we never want a failure here
-        # to annoy users!
-        LOG.debug(f"Error queueing metrics request: {str(ex)}")
+    tracker = initialise_tracker(account)
+    event_params: dict[str, Any] = {
+        "event": action,
+        "properties": {
+            "distinct_id": tracker.last_user,
+            "server_id": tracker.last_server,
+            "token": tracker.analytics_token,
+            "hostApp": HOST_APP,
+            "hostAppVersion": HOST_APP_VERSION,
+            "$os": tracker.platform,
+            "type": "action",
+        },
+    }
+    if custom_props:
+        event_params["properties"].update(custom_props)
+
+    if send_sync:
+        tracker.send_event(event_params)
+    else:
+        tracker.queue_event(event_params)
 
 
-def initialise_tracker(account=None):
+def initialise_tracker(account: Account | None = None) -> "MetricsTracker":
     global METRICS_TRACKER
     if not METRICS_TRACKER:
         METRICS_TRACKER = MetricsTracker()
 
-    if account and account.userInfo.email:
+    if account:
         METRICS_TRACKER.set_last_user(account.userInfo.email)
-    if account and account.serverInfo.url:
         METRICS_TRACKER.set_last_server(account.serverInfo.url)
 
+    return METRICS_TRACKER
+
 
 class Singleton(type):
     _instances = {}
@@ -112,48 +100,62 @@ class Singleton(type):
 
 
 class MetricsTracker(metaclass=Singleton):
-    analytics_url = "https://analytics.speckle.systems/track?ip=1"
-    analytics_token = "acd87c5a50b56df91a795e999812a3a4"
-    last_user = ""
-    last_server = None
-    platform = None
-    sending_thread = None
-    queue = queue.Queue(1000)
+    analytics_url: str = "https://analytics.speckle.systems/track?ip=1"
+    analytics_token: str = "acd87c5a50b56df91a795e999812a3a4"
+    last_user: str = ""
+    last_server: str | None = None
+    platform: str
+
+    _sending_thread: threading.Thread
+    _queue: queue.Queue[dict[str, Any]] = queue.Queue(1000)
+    _session = requests.Session()
 
     def __init__(self) -> None:
-        self.sending_thread = threading.Thread(
+        self._sending_thread = threading.Thread(
             target=self._send_tracking_requests, daemon=True
         )
         self.platform = PLATFORMS.get(sys.platform, "linux")
-        self.sending_thread.start()
+        self._sending_thread.start()
         with contextlib.suppress(Exception):
             node, user = platform.node(), getpass.getuser()
             if node and user:
                 self.last_user = f"@{self.hash(f'{node}-{user}')}"
 
-    def set_last_user(self, email: str):
+    def set_last_user(self, email: str | None) -> None:
         if not email:
             return
         self.last_user = f"@{self.hash(email)}"
 
-    def set_last_server(self, server: str):
+    def set_last_server(self, server: str | None) -> None:
         if not server:
             return
         self.last_server = self.hash(server)
 
-    def hash(self, value: str):
+    def hash(self, value: str) -> str:
         inputList = value.lower().split("://")
         input = inputList[len(inputList) - 1].split("/")[0].split("?")[0]
         return hashlib.md5(input.encode("utf-8")).hexdigest().upper()
 
-    def _send_tracking_requests(self):
-        session = requests.Session()
+    def queue_event(self, event_params: dict[str, Any]) -> None:
+        try:
+            self._queue.put_nowait(event_params)
+        except queue.Full:
+            LOG.warning(
+                "Metrics event was skipped because the metrics queue was was full",
+                exc_info=True,
+            )
+
+    def send_event(self, event_params: dict[str, Any]) -> None:
+        response = self._session.post(self.analytics_url, json=[event_params])
+        response.raise_for_status()
+
+    def _send_tracking_requests(self) -> None:
         while True:
-            event_params = [self.queue.get()]
+            event_params = self._queue.get()
 
             try:
-                session.post(self.analytics_url, json=event_params)
-            except Exception as ex:
-                LOG.debug(f"Error sending metrics request: {str(ex)}")
+                self.send_event(event_params)
+            except Exception:
+                LOG.warning("Error sending metrics request", exc_info=True)
 
-            self.queue.task_done()
+            self._queue.task_done()

src/specklepy/objects/proxies.py

@@ -49,6 +49,26 @@ class InstanceDefinitionProxy(
     name: str
 
 
+@dataclass(kw_only=True)
+class LevelProxy(
+    Base,
+    speckle_type="Objects.Other.LevelProxy",
+    detachable={"objects"},
+):
+    """
+    used to store building storey to object relationships in root collections
+
+    Args:
+        objects (list): the list of application ids of objects in this building storey
+        value (DataObject): the building storey data object with all properties
+        applicationId (str): the GUID of the building storey
+    """
+
+    objects: List[str]
+    value: Base
+    applicationId: str
+
+
 @dataclass(kw_only=True)
 class RenderMaterialProxy(
     Base,

src/specklepy/serialization/base_object_serializer.py

@@ -199,8 +199,9 @@ class BaseObjectSerializer:
 
         # write detached or root objects to transports
         if detached and self.write_transports:
+            serialized_data = ujson.dumps(object_builder)
             for t in self.write_transports:
-                t.save_object(id=obj_id, serialized_object=ujson.dumps(object_builder))
+                t.save_object(id=obj_id, serialized_object=serialized_data)
 
         del self.lineage[-1]
 

src/specklepy/transports/server/batch_sender.py

@@ -7,6 +7,7 @@ import threading
 import requests
 
 from specklepy.logging.exceptions import SpeckleException
+from specklepy.transports.server.retry_policy import setup_session
 
 LOG = logging.getLogger(__name__)
 
@@ -72,10 +73,7 @@ class BatchSender:
 
     def _sending_thread_main(self):
         try:
-            session = requests.Session()
-            session.headers.update(
-                {"Authorization": f"Bearer {self._token}", "Accept": "text/plain"}
-            )
+            session = setup_session(self._token)
 
             while True:
                 batch = self._batches.get()
@@ -123,8 +121,8 @@ class BatchSender:
         upload_data = "[" + ",".join(new_objects) + "]"
         upload_data_gzip = gzip.compress(upload_data.encode())
         LOG.info(
-            "Uploading batch of {batch_size} objects {new_object_count}: ",
-            "(size: {upload_size}, compressed size: {upload_data_size})",
+            "Uploading batch of {batch_size} objects {new_object_count}: "
+            + "(size: {upload_size}, compressed size: {upload_data_size})",
             {
                 "batch_size": len(batch),
                 "new_object_count": len(new_objects),

src/specklepy/transports/server/retry_policy.py

@@ -0,0 +1,46 @@
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+
+def setup_session(auth_token: str | None) -> requests.Session:
+    """
+    Sets up a requests.Session with a basic retry policy
+    to retry on all the usual retryable status codes, with a back off policy:
+        1st: 0ms,
+        2nd: 500ms,
+        3rd: 1500ms.
+
+    Also sets "Accept": "text/plain" header (because this is what ServerTransport needs)
+    and (if a auth_token is provided) the Authorization header
+    """
+
+    session = requests.Session()
+    retry_policy = Retry(
+        total=3,
+        read=3,
+        connect=3,
+        backoff_factor=0.5,
+        status_forcelist=(500, 502, 503, 504, 408, 429),
+        allowed_methods=["HEAD", "GET", "OPTIONS", "POST", "PUT", "DELETE"],
+        raise_on_status=False,
+    )
+
+    adapter = HTTPAdapter(max_retries=retry_policy)
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+
+    session.headers.update(
+        {
+            "Accept": "text/plain",
+        }
+    )
+
+    if auth_token is not None:
+        session.headers.update(
+            {
+                "Authorization": f"Bearer {auth_token}",
+            }
+        )
+
+    return session

src/specklepy/transports/server/server.py

@@ -2,12 +2,11 @@ import json
 from typing import Dict, List, Optional
 from warnings import warn
 
-import requests
-
 from specklepy.core.api.client import SpeckleClient
 from specklepy.core.api.credentials import Account, get_account_from_token
 from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
 from specklepy.transports.abstract_transport import AbstractTransport
+from specklepy.transports.server.retry_policy import setup_session
 
 from .batch_sender import BatchSender
 
@@ -92,23 +91,13 @@ class ServerTransport(AbstractTransport):
         self.stream_id = stream_id
         self.url = url
 
-        self.session = requests.Session()
-
-        self.session.headers.update(
-            {
-                "Accept": "text/plain",
-            }
-        )
-
         if self.account is not None:
             self._batch_sender = BatchSender(
                 self.url, self.stream_id, self.account.token, max_batch_size_mb=1
             )
-            self.session.headers.update(
-                {
-                    "Authorization": f"Bearer {self.account.token}",
-                }
-            )
+        self.session = setup_session(
+            self.account.token if self.account is not None else None
+        )
 
     @property
     def name(self) -> str:

tests/integration/client/current/test_active_user_resource_permissions.py

@@ -0,0 +1,85 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
+from specklepy.core.api.inputs.user_inputs import UserProjectsFilter
+from specklepy.core.api.models.current import (
+    Project,
+    ProjectWithPermissions,
+    ResourceCollection,
+)
+
+
+@pytest.mark.run()
+class TestActiveUserResourcePermissions:
+    @pytest.fixture()
+    def test_project(self, client: SpeckleClient) -> Project:
+        project = client.project.create(
+            ProjectCreateInput(
+                name="test project for active user permissions",
+                description="test description",
+                visibility=None,
+            )
+        )
+        return project
+
+    def test_active_user_get_projects_with_permissions(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        result = client.active_user.get_projects_with_permissions()
+
+        assert isinstance(result, ResourceCollection)
+        assert len(result.items) >= 1
+
+        test_project_with_permissions = None
+        for project in result.items:
+            if project.id == test_project.id:
+                test_project_with_permissions = project
+                break
+
+        assert test_project_with_permissions is not None
+        assert isinstance(test_project_with_permissions, ProjectWithPermissions)
+
+        assert hasattr(test_project_with_permissions, "permissions")
+        assert test_project_with_permissions.permissions is not None
+
+        assert test_project_with_permissions.id == test_project.id
+        assert test_project_with_permissions.name == test_project.name
+
+        permissions = test_project_with_permissions.permissions
+        assert hasattr(permissions, "can_create_model")
+        assert hasattr(permissions, "can_delete")
+        assert hasattr(permissions, "can_load")
+        assert hasattr(permissions, "can_publish")
+
+        assert permissions.can_create_model.authorized is True
+        assert permissions.can_delete.authorized is True
+        assert permissions.can_load.authorized is True
+        assert permissions.can_publish.authorized is True
+
+    def test_active_user_get_projects_with_permissions_with_filter(
+        self, client: SpeckleClient, test_project: Project
+    ):
+        """test getting active user's projects with permissions using a filter."""
+        filter = UserProjectsFilter(search=test_project.name)
+
+        result = client.active_user.get_projects_with_permissions(filter=filter)
+
+        assert isinstance(result, ResourceCollection)
+        assert len(result.items) >= 1
+        assert result.total_count >= 1
+
+        project_with_permissions = result.items[0]
+        assert isinstance(project_with_permissions, ProjectWithPermissions)
+        assert project_with_permissions.id == test_project.id
+
+        assert hasattr(project_with_permissions, "permissions")
+        assert project_with_permissions.permissions is not None
+
+    def test_active_user_projects_with_permissions_method_exists(
+        self, client: SpeckleClient
+    ):
+        """test that the method exists and is callable on active user resource."""
+        assert hasattr(client.active_user, "get_projects_with_permissions")
+        method = client.active_user.get_projects_with_permissions
+        assert callable(method)

tests/integration/client/current/test_file.ifc

@@ -0,0 +1,61 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION ((''), '2;1');
+FILE_NAME ('', '2020-02-27T18:38:58', (''), (''), 'Processor version 5.1.0.0', 'Xbim.IO.MemoryModel', '');
+FILE_SCHEMA (('IFC4'));
+ENDSEC;
+DATA;
+#1=IFCPROJECT('3WoDmit2L9H8xguu5dNQPk',#2,'W\X\FCrfelEinfach',$,$,$,$,(#19,#22),#7);
+#2=IFCOWNERHISTORY(#5,#6,$,.ADDED.,1582828739,$,$,0);
+#3=IFCPERSON($,'Team','Finradon',$,$,$,$,$);
+#4=IFCORGANIZATION($,'CMS',$,$,$);
+#5=IFCPERSONANDORGANIZATION(#3,#4,$);
+#6=IFCAPPLICATION(#4,'1.0','W\X\FCrfelEinfach','W\X\FCrfelEinfach.exe');
+#7=IFCUNITASSIGNMENT((#8,#9,#10,#11,#12,#13,#14,#15,#16));
+#8=IFCSIUNIT(*,.LENGTHUNIT.,.MILLI.,.METRE.);
+#9=IFCSIUNIT(*,.AREAUNIT.,$,.SQUARE_METRE.);
+#10=IFCSIUNIT(*,.VOLUMEUNIT.,$,.CUBIC_METRE.);
+#11=IFCSIUNIT(*,.SOLIDANGLEUNIT.,$,.STERADIAN.);
+#12=IFCSIUNIT(*,.PLANEANGLEUNIT.,$,.RADIAN.);
+#13=IFCSIUNIT(*,.MASSUNIT.,$,.GRAM.);
+#14=IFCSIUNIT(*,.TIMEUNIT.,$,.SECOND.);
+#15=IFCSIUNIT(*,.THERMODYNAMICTEMPERATUREUNIT.,$,.DEGREE_CELSIUS.);
+#16=IFCSIUNIT(*,.LUMINOUSINTENSITYUNIT.,$,.LUMEN.);
+#17=IFCCARTESIANPOINT((0.,0.,0.));
+#18=IFCAXIS2PLACEMENT3D(#17,$,$);
+#19=IFCGEOMETRICREPRESENTATIONCONTEXT('Building Model','Model',3,1.E-05,#18,$);
+#20=IFCCARTESIANPOINT((0.,0.));
+#21=IFCAXIS2PLACEMENT2D(#20,$);
+#22=IFCGEOMETRICREPRESENTATIONCONTEXT('Building Plan View','Plan',2,1.E-05,#21,$);
+#23=IFCBUILDING('1fOYmUWu5FGA6WZZJzE67P',#2,'Default Building',$,$,#24,$,$,.ELEMENT.,$,$,$);
+#24=IFCLOCALPLACEMENT($,#25);
+#25=IFCAXIS2PLACEMENT3D(#26,$,$);
+#26=IFCCARTESIANPOINT((0.,0.,0.));
+#27=IFCRELAGGREGATES('0yprV4hG98I8MgBrMkyNIg',#2,$,$,#1,(#23));
+#28=IFCBUILDINGELEMENTPROXY('18CFESN5fCsuplarC$2Ulg',#2,'The cube in question',$,$,#38,#37,$,$);
+#29=IFCRECTANGLEPROFILEDEF(.AREA.,$,#31,820.,820.);
+#30=IFCCARTESIANPOINT((0.,40.));
+#31=IFCAXIS2PLACEMENT2D(#30,$);
+#32=IFCEXTRUDEDAREASOLID(#29,#35,#33,820.);
+#33=IFCDIRECTION((0.,0.,1.));
+#34=IFCCARTESIANPOINT((0.,0.,0.));
+#35=IFCAXIS2PLACEMENT3D(#34,$,$);
+#36=IFCSHAPEREPRESENTATION(#19,'Body','SweptSolid',(#32));
+#37=IFCPRODUCTDEFINITIONSHAPE($,$,(#36,#51));
+#38=IFCLOCALPLACEMENT($,#39);
+#39=IFCAXIS2PLACEMENT3D(#34,#41,#40);
+#40=IFCDIRECTION((0.,1.,0.));
+#41=IFCDIRECTION((0.,0.,1.));
+#42=IFCMATERIALLAYERSETUSAGE(#43,.AXIS2.,.NEGATIVE.,150.,$);
+#43=IFCMATERIALLAYERSET((#44),$,$);
+#44=IFCMATERIALLAYER($,10.,$,$,$,$,$);
+#45=IFCMATERIAL('Metal + Glass',$,$);
+#46=IFCRELASSOCIATESMATERIAL('2NhfPxMdr8_v0TKa3nx$N_',#2,$,$,(#28),#42);
+#47=IFCPRESENTATIONLAYERASSIGNMENT('some ifcPresentationLayerAssignment',$,(#36),$);
+#48=IFCPOLYLINE((#49,#50));
+#49=IFCCARTESIANPOINT((0.,0.));
+#50=IFCCARTESIANPOINT((4000.,0.));
+#51=IFCSHAPEREPRESENTATION(#19,'Axis','Curve2D',(#48));
+#52=IFCRELCONTAINEDINSPATIALSTRUCTURE('2KE_68CXDAFvue7XfUwVHI',#2,$,$,(#28),#23);
+ENDSEC;
+END-ISO-10303-21;

tests/integration/client/current/test_file_import_resource.py

@@ -0,0 +1,251 @@
+from pathlib import Path
+
+import pytest
+
+from specklepy.api import operations
+from specklepy.api.client import SpeckleClient
+from specklepy.core.api.enums import ProjectVisibility
+from specklepy.core.api.inputs.file_import_inputs import (
+    FileImportErrorInput,
+    FileImportResult,
+    FileImportSuccessInput,
+    GenerateFileUploadUrlInput,
+    StartFileImportInput,
+)
+from specklepy.core.api.inputs.model_inputs import CreateModelInput
+from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
+from specklepy.core.api.inputs.version_inputs import CreateVersionInput
+from specklepy.core.api.models import Project
+from specklepy.core.api.models.current import FileUploadUrl
+from specklepy.core.helpers import crypto_random_string
+from specklepy.transports.server.server import ServerTransport
+from tests.integration.fakemesh import FakeMesh
+
+
+class TestFileImportResource:
+    @pytest.fixture
+    def file_path(self) -> Path:
+        path = Path("./tests/integration/client/current/test_file.ifc").absolute()
+        assert path.exists()
+        return path
+
+    @pytest.fixture
+    def project(self, client: SpeckleClient) -> Project:
+        return client.project.create(
+            ProjectCreateInput(
+                name="test", description=None, visibility=ProjectVisibility.PRIVATE
+            )
+        )
+
+    @pytest.fixture(scope="function")
+    def upload_url(
+        self, project: Project, file_path: Path, client: SpeckleClient
+    ) -> FileUploadUrl:
+        upload_url_result = client.file_import.generate_upload_url(
+            GenerateFileUploadUrlInput(project_id=project.id, file_name=file_path.name)
+        )
+        return upload_url_result
+
+    def test_generate_upload_url(self, upload_url: FileUploadUrl) -> None:
+        assert upload_url.file_id
+        assert upload_url.url
+
+    def test_upload_file(
+        self, file_path: Path, client: SpeckleClient, upload_url: FileUploadUrl
+    ) -> None:
+        response = client.file_import.upload_file(file=file_path, url=upload_url.url)
+        assert response.etag
+
+    def test_download_file(
+        self,
+        file_path: Path,
+        client: SpeckleClient,
+        project: Project,
+        upload_url: FileUploadUrl,
+    ) -> None:
+        _ = client.file_import.upload_file(file=file_path, url=upload_url.url)
+
+        target_file = file_path.parent.joinpath("download.ifc")
+
+        downloaded_file = client.file_import.download_file(
+            project_id=project.id, file_id=upload_url.file_id, target_file=target_file
+        )
+
+        assert downloaded_file.exists()
+
+        assert file_path.stat().st_size == downloaded_file.stat().st_size
+
+        downloaded_file.unlink()
+
+    def test_start_file_import(
+        self,
+        file_path: Path,
+        client: SpeckleClient,
+        project: Project,
+        upload_url: FileUploadUrl,
+    ) -> None:
+        model = client.model.create(
+            CreateModelInput(name=crypto_random_string(10), project_id=project.id)
+        )
+        upload_response = client.file_import.upload_file(
+            file=file_path, url=upload_url.url
+        )
+        response = client.file_import.start_file_import(
+            StartFileImportInput(
+                project_id=project.id,
+                model_id=model.id,
+                file_id=upload_url.file_id,
+                etag=upload_response.etag,
+            )
+        )
+
+        assert response.converted_status == 0
+        assert response.converted_version_id is None
+
+        upload_jobs = client.file_import.get_model_file_import_jobs(
+            project_id=project.id,
+            model_id=model.id,
+        )
+
+        assert upload_jobs.total_count == 1
+        job = upload_jobs.items[0]
+        assert job
+        assert job.converted_status == 0
+        assert job.converted_version_id is None
+
+    def test_finish_file_import_success(
+        self,
+        file_path: Path,
+        client: SpeckleClient,
+        project: Project,
+        upload_url: FileUploadUrl,
+        mesh: FakeMesh,
+    ) -> None:
+        model = client.model.create(
+            CreateModelInput(name=crypto_random_string(10), project_id=project.id)
+        )
+        upload_response = client.file_import.upload_file(
+            file=file_path, url=upload_url.url
+        )
+        job_response = client.file_import.start_file_import(
+            StartFileImportInput(
+                project_id=project.id,
+                model_id=model.id,
+                file_id=upload_url.file_id,
+                etag=upload_response.etag,
+            )
+        )
+
+        assert job_response.converted_status == 0
+        assert job_response.converted_version_id is None
+
+        upload_jobs = client.file_import.get_model_file_import_jobs(
+            project_id=project.id,
+            model_id=model.id,
+        )
+
+        assert upload_jobs.total_count == 1
+        job = upload_jobs.items[0]
+        assert job
+        assert job.converted_status == 0
+        assert job.converted_version_id is None
+
+        transport = ServerTransport(client=client, stream_id=project.id)
+        hash = operations.send(mesh, transports=[transport])
+
+        version = client.version.create(
+            input=CreateVersionInput(
+                project_id=project.id, model_id=model.id, object_id=hash
+            )
+        )
+
+        finish_result = client.file_import.finish_file_import_job(
+            input=FileImportSuccessInput(
+                project_id=project.id,
+                job_id=job_response.id,
+                result=FileImportResult(
+                    download_duration_seconds=0,
+                    duration_seconds=0,
+                    parse_duration_seconds=0,
+                    parser="test",
+                    version_id=version.id,
+                ),
+            )
+        )
+
+        assert finish_result
+
+        upload_jobs = client.file_import.get_model_file_import_jobs(
+            project_id=project.id,
+            model_id=model.id,
+        )
+
+        assert upload_jobs.total_count == 1
+        job = upload_jobs.items[0]
+        assert job
+        assert job.converted_status == 2
+        assert job.converted_version_id == version.id
+
+    def test_finish_file_import_error(
+        self,
+        file_path: Path,
+        client: SpeckleClient,
+        project: Project,
+        upload_url: FileUploadUrl,
+    ) -> None:
+        model = client.model.create(
+            CreateModelInput(name=crypto_random_string(10), project_id=project.id)
+        )
+        upload_response = client.file_import.upload_file(
+            file=file_path, url=upload_url.url
+        )
+        job_response = client.file_import.start_file_import(
+            StartFileImportInput(
+                project_id=project.id,
+                model_id=model.id,
+                file_id=upload_url.file_id,
+                etag=upload_response.etag,
+            )
+        )
+
+        assert job_response.converted_status == 0
+        assert job_response.converted_version_id is None
+
+        upload_jobs = client.file_import.get_model_file_import_jobs(
+            project_id=project.id,
+            model_id=model.id,
+        )
+
+        assert upload_jobs.total_count == 1
+        job = upload_jobs.items[0]
+        assert job
+        assert job.converted_status == 0
+        assert job.converted_version_id is None
+
+        finish_result = client.file_import.finish_file_import_job(
+            input=FileImportErrorInput(
+                project_id=project.id,
+                job_id=job_response.id,
+                reason="Test error",
+                result=FileImportResult(
+                    download_duration_seconds=0,
+                    duration_seconds=0,
+                    parse_duration_seconds=0,
+                    parser="test",
+                    version_id=None,
+                ),
+            )
+        )
+
+        assert finish_result
+
+        upload_jobs = client.file_import.get_model_file_import_jobs(
+            project_id=project.id,
+            model_id=model.id,
+        )
+
+        assert upload_jobs.total_count == 1
+        job = upload_jobs.items[0]
+        assert job
+        assert job.converted_status == 3
+        assert job.converted_version_id is None

tests/integration/client/current/test_workspace_resource_permissions.py

@@ -0,0 +1,19 @@
+import pytest
+
+from specklepy.api.client import SpeckleClient
+from specklepy.logging.exceptions import GraphQLException
+
+
+@pytest.mark.run()
+class TestWorkspaceResourcePermissions:
+    def test_get_projects_with_permissions(self, client: SpeckleClient):
+        with pytest.raises(GraphQLException):
+            client.workspace.get_projects_with_permissions("not a real id")
+
+    def test_get_projects_with_permissions_method_exists(self, client: SpeckleClient):
+        """
+        test that the method exists with the correct signature.
+        """
+        assert hasattr(client.workspace, "get_projects_with_permissions")
+        method = client.workspace.get_projects_with_permissions
+        assert callable(method)

tests/integration/client/test_client_and_ops.py

@@ -6,7 +6,7 @@ from specklepy.api import operations
 from specklepy.api.client import SpeckleClient
 from specklepy.api.credentials import Account, get_account_from_token
 from specklepy.core.helpers import speckle_path_provider
-from specklepy.logging.exceptions import SpeckleException, SpeckleWarning
+from specklepy.logging.exceptions import SpeckleException
 from specklepy.objects.base import Base
 from specklepy.transports.server import ServerTransport
 
@@ -17,7 +17,7 @@ def test_invalid_authentication():
     speckle_path_provider.override_application_data_path(gettempdir())
     client = SpeckleClient()
 
-    with pytest.warns(SpeckleWarning):
+    with pytest.raises(SpeckleException):
         client.authenticate_with_token("fake token")
 
     # remove path override

tests/integration/conftest.py

@@ -8,11 +8,12 @@ import requests
 
 from specklepy.api.client import SpeckleClient
 from specklepy.core.api import operations
+from specklepy.core.api.credentials import Account, UserInfo
 from specklepy.core.api.enums import ProjectVisibility
 from specklepy.core.api.inputs.project_inputs import ProjectCreateInput
 from specklepy.core.api.inputs.version_inputs import CreateVersionInput
 from specklepy.core.api.models import Version
-from specklepy.core.api.models.current import Project
+from specklepy.core.api.models.current import Project, ServerInfo
 from specklepy.logging import metrics
 from specklepy.objects.base import Base
 from specklepy.objects.geometry import Point
@@ -89,13 +90,15 @@ def second_user_dict(host: str) -> Dict[str, str]:
 def create_client(host: str, token: str) -> SpeckleClient:
     client = SpeckleClient(host=host, use_ssl=False)
     client.authenticate_with_token(token)
-    user = client.active_user.get()
-    assert user
-    client.account.userInfo.id = user.id
-    client.account.userInfo.email = user.email
-    client.account.userInfo.name = user.name
-    client.account.userInfo.company = user.company
-    client.account.userInfo.avatar = user.avatar
+
+    assert isinstance(client.account, Account)
+    assert isinstance(client.account.userInfo, UserInfo)
+    assert client.account.userInfo.id
+    assert client.account.userInfo.name
+    assert isinstance(client.account.serverInfo, ServerInfo)
+    assert client.account.serverInfo.url
+    assert client.account.serverInfo.name
+
     return client
 
 

tests/integration/speckle_automate/test_automation_context.py

@@ -15,11 +15,11 @@ from speckle_automate import (
 )
 from speckle_automate.fixtures import (
     create_test_automation_run_data,
-    crypto_random_string,
 )
 from speckle_automate.schema import AutomateBase
 from specklepy.api.client import SpeckleClient
 from specklepy.core.api.models.current import Model, Version
+from specklepy.core.helpers import crypto_random_string
 from specklepy.objects.base import Base
 
 

tests/integration/test_connector_versions.py

@@ -0,0 +1,32 @@
+import pytest
+from httpx import HTTPStatusError
+
+from specklepy.core.api.connector_versions import (
+    ConnectorVersion,
+    ConnectorVersions,
+    get_connector_versions,
+    get_latest_version,
+)
+
+# NOTE: the tests in this file are testing against the live releases.speckle.dev server
+# url defined in get_connector_versions.
+
+
+def test_connector_versions():
+    res = get_connector_versions("blender")
+
+    assert isinstance(res, ConnectorVersions)
+    assert res.versions  # Assuming the feed is not empty
+
+
+def test_get_latest_version_throws_no_slug():
+    with pytest.raises(HTTPStatusError) as ex:
+        get_latest_version("non-existent-connector!", True)
+
+    assert "404" in str(ex.value)
+
+
+def test_get_latest_version():
+    res = get_latest_version("blender", False)
+
+    assert isinstance(res, ConnectorVersion)

tests/unit/test_setup_session.py

@@ -0,0 +1,20 @@
+import requests
+
+from specklepy.transports.server.retry_policy import setup_session
+
+
+def test_session_headers_without_auth():
+    """Check that Accept header is set and Authorization is not."""
+    session = setup_session(None)
+    assert isinstance(session, requests.Session)
+    assert session.headers["Accept"] == "text/plain"
+    assert "Authorization" not in session.headers
+
+
+def test_session_headers_with_auth():
+    """Check that Authorization header is properly added."""
+    token = "abc123"
+    session = setup_session(token)
+    assert isinstance(session, requests.Session)
+    assert session.headers["Authorization"] == f"Bearer {token}"
+    assert session.headers["Accept"] == "text/plain"

uv.lock

@@ -1,5 +1,9 @@
 version = 1
 requires-python = ">=3.10.0, <4.0"
+resolution-markers = [
+    "python_full_version >= '3.11'",
+    "python_full_version < '3.11'",
+]
 
 [[package]]
 name = "annotated-types"
@@ -581,6 +585,42 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
 ]
 
+[[package]]
+name = "ifcopenshell"
+version = "0.8.3.post2"
+source = { registry = "https://pypi.org/simple/" }
+dependencies = [
+    { name = "isodate" },
+    { name = "lark" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11'" },
+    { name = "python-dateutil" },
+    { name = "shapely" },
+    { name = "typing-extensions" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/da/fa961f411d70da77bdce27f0687ce0c5570226b9128cd24e7126638ae198/ifcopenshell-0.8.3.post2-py310-none-macosx_10_15_x86_64.whl", hash = "sha256:35e548b6af5cd29d17dd7df6edfcb578acccb22f88535cebdb558752941e7c25", size = 39850896 },
+    { url = "https://files.pythonhosted.org/packages/f3/3e/f9f6a910adea76af81a890747ddfd49839c9b1cba85b726ee864605e5624/ifcopenshell-0.8.3.post2-py310-none-macosx_11_0_arm64.whl", hash = "sha256:32b35c13ca6e3c02e8f84d5c96cd205cc64d54930f552f19f42cdfd89f4e4a05", size = 39140289 },
+    { url = "https://files.pythonhosted.org/packages/5d/47/9fe1eabc28c86486a73ad721c25f0f1958fb2b3ffea009057c313f1c09e5/ifcopenshell-0.8.3.post2-py310-none-manylinux_2_31_x86_64.whl", hash = "sha256:52b984f15dfe0dad765d2ea1dc8afd7d95aaf4327760eada54a500753cdff1c7", size = 40948394 },
+    { url = "https://files.pythonhosted.org/packages/51/b9/b67fb48d2ee54d7f60ef9c9f10f8132ba9cb2a42216fcbdfc05eb29f1825/ifcopenshell-0.8.3.post2-py310-none-win_amd64.whl", hash = "sha256:27cdc9cd5c78742a128b606da1afa6e4d179f718c68e7e13b4c3a926e23ea2c7", size = 21618154 },
+    { url = "https://files.pythonhosted.org/packages/b9/8b/c9a4d6448571730e8ce83d57d2b0b692be494692af37bdefa8c1b8b5e605/ifcopenshell-0.8.3.post2-py311-none-macosx_10_15_x86_64.whl", hash = "sha256:40403fdea2715ea3ff3fabfa655a46973bbc004d22396bec0980b3c76b24f54f", size = 39850896 },
+    { url = "https://files.pythonhosted.org/packages/50/e6/9d6c512eee2ece0908dd312432ecd4398960e912a517ff6f5d3acdf1bde3/ifcopenshell-0.8.3.post2-py311-none-macosx_11_0_arm64.whl", hash = "sha256:dd312e276ed54c044ef04f495852c3ac26c94c516c5ff18d545c58b1513547c6", size = 39140293 },
+    { url = "https://files.pythonhosted.org/packages/3e/0d/15120e669b09b56204b422dcebc5b58b3812c0a29145e694c165388bf8f7/ifcopenshell-0.8.3.post2-py311-none-manylinux_2_31_x86_64.whl", hash = "sha256:49c1690d1fdc5a1a54ae1feb042b33b9d8fe96d3af5cfed2f9c76c01fa6d0635", size = 41309792 },
+    { url = "https://files.pythonhosted.org/packages/92/15/ff52115de4dc5c9d588246bccbb24d8f8df56ee29dd6a0dd832c23d37016/ifcopenshell-0.8.3.post2-py311-none-win_amd64.whl", hash = "sha256:e4f1895abd1831e7d21af0dd30645144e7e2d50996caaf35c3d91ae3b1eb98f5", size = 21618411 },
+    { url = "https://files.pythonhosted.org/packages/4e/f7/c2c51f5d4bc5dd78c378b20c3aa7e3724e99c2999bfe8058a8e97dc51f4d/ifcopenshell-0.8.3.post2-py312-none-macosx_10_15_x86_64.whl", hash = "sha256:0070c15a80feb5d22bd573692096148ca0beaff85b44fc8391311c051997ae80", size = 39861249 },
+    { url = "https://files.pythonhosted.org/packages/ff/b7/1188295a016c36d080993a2b55f267f200afbf1298cfd8b719bd4c8141d7/ifcopenshell-0.8.3.post2-py312-none-macosx_11_0_arm64.whl", hash = "sha256:08d55305d692860aef88f784c51d2fc9477f01c9b2c1af9d4a87f968798ee78d", size = 39117661 },
+    { url = "https://files.pythonhosted.org/packages/49/74/8d0625f8eb39596503a9d24f610274030ff47a6f856ba874d06c98015548/ifcopenshell-0.8.3.post2-py312-none-manylinux_2_31_x86_64.whl", hash = "sha256:9e9e86f7a01049e13866689a1ac1ffcffceb05af1dda9da50e5e409071909f06", size = 41590131 },
+    { url = "https://files.pythonhosted.org/packages/e1/b2/2a85af106d933585099c391743c2ae1d700ef615484b69ad10c65ab74d8a/ifcopenshell-0.8.3.post2-py312-none-win_amd64.whl", hash = "sha256:ac0d78e5ef868f7b4764d0d9cd0acd0780bf76d9e0c224a5ff3970bfedb442b3", size = 21620494 },
+    { url = "https://files.pythonhosted.org/packages/e5/a7/13ebb6fce89a6731cc2b27ac62b69800cec72c6ca35fec273232bad0a0e6/ifcopenshell-0.8.3.post2-py313-none-macosx_10_15_x86_64.whl", hash = "sha256:b7d176f8b32c7e4f572a2f351e39224b9c4adec455041865968890008cf8b883", size = 39861243 },
+    { url = "https://files.pythonhosted.org/packages/18/c6/5cc422a7980a413777ce3fe264d98880508830fc25808653d773551f71ef/ifcopenshell-0.8.3.post2-py313-none-macosx_11_0_arm64.whl", hash = "sha256:cd1003bd0a96e5aa23c9ce48827139f55e77bd632baede7f4d5b0263f162d9c9", size = 39117664 },
+    { url = "https://files.pythonhosted.org/packages/9c/a5/ea2d0fddecce268621dd89bdefa5c13833109a08a698231589235b44f1e2/ifcopenshell-0.8.3.post2-py313-none-manylinux_2_31_x86_64.whl", hash = "sha256:f13738caa346d5816e63f0886b645f8bf53e978a9bc4047df5a755507a4c4fbe", size = 41428605 },
+    { url = "https://files.pythonhosted.org/packages/2d/ba/30184ed671e7e73e5777cd7ad24d5b37ea8e5c962b0c70134d45447038c1/ifcopenshell-0.8.3.post2-py313-none-win_amd64.whl", hash = "sha256:6075b06302fd9c67adea16854cd626b45ecd2ad53199b55ce0bfee135c92a91a", size = 21620061 },
+    { url = "https://files.pythonhosted.org/packages/80/49/8f736f8665c65dc064c54d40079081b2edb6e84b00b64f16b9110f58d558/ifcopenshell-0.8.3.post2-py39-none-macosx_10_15_x86_64.whl", hash = "sha256:aeb9dd43c4f0fd61c94f3a3868df38ebce00a3c21650dda4ef9559689ab4a1f9", size = 39850893 },
+    { url = "https://files.pythonhosted.org/packages/74/48/cdfa5bf1a078d81df3ae57fa237acc312ca7cb9cb1d9822cb1020f255f2d/ifcopenshell-0.8.3.post2-py39-none-macosx_11_0_arm64.whl", hash = "sha256:e20d426cd8a594585d7198212691da03a331cb5107172e1fe0b55e9403929338", size = 39140290 },
+    { url = "https://files.pythonhosted.org/packages/19/84/a2baff24a9aded15113ddd03107614e36a3d6bd698a7c7a14ecc18bf1e83/ifcopenshell-0.8.3.post2-py39-none-manylinux_2_31_x86_64.whl", hash = "sha256:f0458b6e2a89ed082273671430a36811c5ef5d08bdd7d3711115c7fecc8f910f", size = 40917046 },
+    { url = "https://files.pythonhosted.org/packages/b8/55/b21cf709e919962f4205c53ea4e6e78304db5c5a53e28230cbd6bbb01ddf/ifcopenshell-0.8.3.post2-py39-none-win_amd64.whl", hash = "sha256:6e560505805f69f651cc315ea19d5f420baa725060cd12e3454016fb3915c72b", size = 21619507 },
+]
+
 [[package]]
 name = "importlib-metadata"
 version = "8.6.1"
@@ -602,6 +642,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
 ]
 
+[[package]]
+name = "isodate"
+version = "0.7.2"
+source = { registry = "https://pypi.org/simple/" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/4d/e940025e2ce31a8ce1202635910747e5a87cc3a6a6bb2d00973375014749/isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6", size = 29705 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320 },
+]
+
 [[package]]
 name = "jaraco-classes"
 version = "3.4.0"
@@ -677,6 +726,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d3/32/da7f44bcb1105d3e88a0b74ebdca50c59121d2ddf71c9e34ba47df7f3a56/keyring-25.6.0-py3-none-any.whl", hash = "sha256:552a3f7af126ece7ed5c89753650eec89c7eaae8617d0aa4d9ad2b75111266bd", size = 39085 },
 ]
 
+[[package]]
+name = "lark"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple/" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/60/bc7622aefb2aee1c0b4ba23c1446d3e30225c8770b38d7aedbfb65ca9d5a/lark-1.2.2.tar.gz", hash = "sha256:ca807d0162cd16cef15a8feecb862d7319e7a09bdb13aef927968e45040fed80", size = 252132 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/00/d90b10b962b4277f5e64a78b6609968859ff86889f5b898c1a778c06ec00/lark-1.2.2-py3-none-any.whl", hash = "sha256:c2276486b02f0f1b90be155f2c8ba4a8e194d42775786db622faccd652d8e80c", size = 111036 },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "3.0.0"
@@ -846,6 +904,132 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 },
 ]
 
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple/" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245 },
+    { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048 },
+    { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542 },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301 },
+    { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320 },
+    { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050 },
+    { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034 },
+    { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185 },
+    { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149 },
+    { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620 },
+    { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963 },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743 },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616 },
+    { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579 },
+    { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005 },
+    { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570 },
+    { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548 },
+    { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521 },
+    { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866 },
+    { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455 },
+    { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348 },
+    { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362 },
+    { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103 },
+    { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382 },
+    { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462 },
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618 },
+    { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511 },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783 },
+    { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506 },
+    { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190 },
+    { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828 },
+    { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006 },
+    { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765 },
+    { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736 },
+    { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719 },
+    { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072 },
+    { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213 },
+    { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632 },
+    { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532 },
+    { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885 },
+    { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467 },
+    { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144 },
+    { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217 },
+    { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014 },
+    { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935 },
+    { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122 },
+    { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143 },
+    { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260 },
+    { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225 },
+    { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374 },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391 },
+    { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754 },
+    { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476 },
+    { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666 },
+]
+
+[[package]]
+name = "numpy"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple/" }
+resolution-markers = [
+    "python_full_version >= '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2e/19/d7c972dfe90a353dbd3efbbe1d14a5951de80c99c9dc1b93cd998d51dc0f/numpy-2.3.1.tar.gz", hash = "sha256:1ec9ae20a4226da374362cca3c62cd753faf2f951440b0e3b98e93c235441d2b", size = 20390372 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b0/c7/87c64d7ab426156530676000c94784ef55676df2f13b2796f97722464124/numpy-2.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6ea9e48336a402551f52cd8f593343699003d2353daa4b72ce8d34f66b722070", size = 21199346 },
+    { url = "https://files.pythonhosted.org/packages/58/0e/0966c2f44beeac12af8d836e5b5f826a407cf34c45cb73ddcdfce9f5960b/numpy-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ccb7336eaf0e77c1635b232c141846493a588ec9ea777a7c24d7166bb8533ae", size = 14361143 },
+    { url = "https://files.pythonhosted.org/packages/7d/31/6e35a247acb1bfc19226791dfc7d4c30002cd4e620e11e58b0ddf836fe52/numpy-2.3.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0bb3a4a61e1d327e035275d2a993c96fa786e4913aa089843e6a2d9dd205c66a", size = 5378989 },
+    { url = "https://files.pythonhosted.org/packages/b0/25/93b621219bb6f5a2d4e713a824522c69ab1f06a57cd571cda70e2e31af44/numpy-2.3.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:e344eb79dab01f1e838ebb67aab09965fb271d6da6b00adda26328ac27d4a66e", size = 6912890 },
+    { url = "https://files.pythonhosted.org/packages/ef/60/6b06ed98d11fb32e27fb59468b42383f3877146d3ee639f733776b6ac596/numpy-2.3.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:467db865b392168ceb1ef1ffa6f5a86e62468c43e0cfb4ab6da667ede10e58db", size = 14569032 },
+    { url = "https://files.pythonhosted.org/packages/75/c9/9bec03675192077467a9c7c2bdd1f2e922bd01d3a69b15c3a0fdcd8548f6/numpy-2.3.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:afed2ce4a84f6b0fc6c1ce734ff368cbf5a5e24e8954a338f3bdffa0718adffb", size = 16930354 },
+    { url = "https://files.pythonhosted.org/packages/6a/e2/5756a00cabcf50a3f527a0c968b2b4881c62b1379223931853114fa04cda/numpy-2.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0025048b3c1557a20bc80d06fdeb8cc7fc193721484cca82b2cfa072fec71a93", size = 15879605 },
+    { url = "https://files.pythonhosted.org/packages/ff/86/a471f65f0a86f1ca62dcc90b9fa46174dd48f50214e5446bc16a775646c5/numpy-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5ee121b60aa509679b682819c602579e1df14a5b07fe95671c8849aad8f2115", size = 18666994 },
+    { url = "https://files.pythonhosted.org/packages/43/a6/482a53e469b32be6500aaf61cfafd1de7a0b0d484babf679209c3298852e/numpy-2.3.1-cp311-cp311-win32.whl", hash = "sha256:a8b740f5579ae4585831b3cf0e3b0425c667274f82a484866d2adf9570539369", size = 6603672 },
+    { url = "https://files.pythonhosted.org/packages/6b/fb/bb613f4122c310a13ec67585c70e14b03bfc7ebabd24f4d5138b97371d7c/numpy-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4580adadc53311b163444f877e0789f1c8861e2698f6b2a4ca852fda154f3ff", size = 13024015 },
+    { url = "https://files.pythonhosted.org/packages/51/58/2d842825af9a0c041aca246dc92eb725e1bc5e1c9ac89712625db0c4e11c/numpy-2.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:ec0bdafa906f95adc9a0c6f26a4871fa753f25caaa0e032578a30457bff0af6a", size = 10456989 },
+    { url = "https://files.pythonhosted.org/packages/c6/56/71ad5022e2f63cfe0ca93559403d0edef14aea70a841d640bd13cdba578e/numpy-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2959d8f268f3d8ee402b04a9ec4bb7604555aeacf78b360dc4ec27f1d508177d", size = 20896664 },
+    { url = "https://files.pythonhosted.org/packages/25/65/2db52ba049813670f7f987cc5db6dac9be7cd95e923cc6832b3d32d87cef/numpy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:762e0c0c6b56bdedfef9a8e1d4538556438288c4276901ea008ae44091954e29", size = 14131078 },
+    { url = "https://files.pythonhosted.org/packages/57/dd/28fa3c17b0e751047ac928c1e1b6990238faad76e9b147e585b573d9d1bd/numpy-2.3.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:867ef172a0976aaa1f1d1b63cf2090de8b636a7674607d514505fb7276ab08fc", size = 5112554 },
+    { url = "https://files.pythonhosted.org/packages/c9/fc/84ea0cba8e760c4644b708b6819d91784c290288c27aca916115e3311d17/numpy-2.3.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:4e602e1b8682c2b833af89ba641ad4176053aaa50f5cacda1a27004352dde943", size = 6646560 },
+    { url = "https://files.pythonhosted.org/packages/61/b2/512b0c2ddec985ad1e496b0bd853eeb572315c0f07cd6997473ced8f15e2/numpy-2.3.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8e333040d069eba1652fb08962ec5b76af7f2c7bce1df7e1418c8055cf776f25", size = 14260638 },
+    { url = "https://files.pythonhosted.org/packages/6e/45/c51cb248e679a6c6ab14b7a8e3ead3f4a3fe7425fc7a6f98b3f147bec532/numpy-2.3.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e7cbf5a5eafd8d230a3ce356d892512185230e4781a361229bd902ff403bc660", size = 16632729 },
+    { url = "https://files.pythonhosted.org/packages/e4/ff/feb4be2e5c09a3da161b412019caf47183099cbea1132fd98061808c2df2/numpy-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f1b8f26d1086835f442286c1d9b64bb3974b0b1e41bb105358fd07d20872952", size = 15565330 },
+    { url = "https://files.pythonhosted.org/packages/bc/6d/ceafe87587101e9ab0d370e4f6e5f3f3a85b9a697f2318738e5e7e176ce3/numpy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ee8340cb48c9b7a5899d1149eece41ca535513a9698098edbade2a8e7a84da77", size = 18361734 },
+    { url = "https://files.pythonhosted.org/packages/2b/19/0fb49a3ea088be691f040c9bf1817e4669a339d6e98579f91859b902c636/numpy-2.3.1-cp312-cp312-win32.whl", hash = "sha256:e772dda20a6002ef7061713dc1e2585bc1b534e7909b2030b5a46dae8ff077ab", size = 6320411 },
+    { url = "https://files.pythonhosted.org/packages/b1/3e/e28f4c1dd9e042eb57a3eb652f200225e311b608632bc727ae378623d4f8/numpy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cfecc7822543abdea6de08758091da655ea2210b8ffa1faf116b940693d3df76", size = 12734973 },
+    { url = "https://files.pythonhosted.org/packages/04/a8/8a5e9079dc722acf53522b8f8842e79541ea81835e9b5483388701421073/numpy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:7be91b2239af2658653c5bb6f1b8bccafaf08226a258caf78ce44710a0160d30", size = 10191491 },
+    { url = "https://files.pythonhosted.org/packages/d4/bd/35ad97006d8abff8631293f8ea6adf07b0108ce6fec68da3c3fcca1197f2/numpy-2.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25a1992b0a3fdcdaec9f552ef10d8103186f5397ab45e2d25f8ac51b1a6b97e8", size = 20889381 },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/df5923874d8095b6062495b39729178eef4a922119cee32a12ee1bd4664c/numpy-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7dea630156d39b02a63c18f508f85010230409db5b2927ba59c8ba4ab3e8272e", size = 14152726 },
+    { url = "https://files.pythonhosted.org/packages/8c/0f/a1f269b125806212a876f7efb049b06c6f8772cf0121139f97774cd95626/numpy-2.3.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:bada6058dd886061f10ea15f230ccf7dfff40572e99fef440a4a857c8728c9c0", size = 5105145 },
+    { url = "https://files.pythonhosted.org/packages/6d/63/a7f7fd5f375b0361682f6ffbf686787e82b7bbd561268e4f30afad2bb3c0/numpy-2.3.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:a894f3816eb17b29e4783e5873f92faf55b710c2519e5c351767c51f79d8526d", size = 6639409 },
+    { url = "https://files.pythonhosted.org/packages/bf/0d/1854a4121af895aab383f4aa233748f1df4671ef331d898e32426756a8a6/numpy-2.3.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:18703df6c4a4fee55fd3d6e5a253d01c5d33a295409b03fda0c86b3ca2ff41a1", size = 14257630 },
+    { url = "https://files.pythonhosted.org/packages/50/30/af1b277b443f2fb08acf1c55ce9d68ee540043f158630d62cef012750f9f/numpy-2.3.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5902660491bd7a48b2ec16c23ccb9124b8abfd9583c5fdfa123fe6b421e03de1", size = 16627546 },
+    { url = "https://files.pythonhosted.org/packages/6e/ec/3b68220c277e463095342d254c61be8144c31208db18d3fd8ef02712bcd6/numpy-2.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:36890eb9e9d2081137bd78d29050ba63b8dab95dff7912eadf1185e80074b2a0", size = 15562538 },
+    { url = "https://files.pythonhosted.org/packages/77/2b/4014f2bcc4404484021c74d4c5ee8eb3de7e3f7ac75f06672f8dcf85140a/numpy-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a780033466159c2270531e2b8ac063704592a0bc62ec4a1b991c7c40705eb0e8", size = 18360327 },
+    { url = "https://files.pythonhosted.org/packages/40/8d/2ddd6c9b30fcf920837b8672f6c65590c7d92e43084c25fc65edc22e93ca/numpy-2.3.1-cp313-cp313-win32.whl", hash = "sha256:39bff12c076812595c3a306f22bfe49919c5513aa1e0e70fac756a0be7c2a2b8", size = 6312330 },
+    { url = "https://files.pythonhosted.org/packages/dd/c8/beaba449925988d415efccb45bf977ff8327a02f655090627318f6398c7b/numpy-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d5ee6eec45f08ce507a6570e06f2f879b374a552087a4179ea7838edbcbfa42", size = 12731565 },
+    { url = "https://files.pythonhosted.org/packages/0b/c3/5c0c575d7ec78c1126998071f58facfc124006635da75b090805e642c62e/numpy-2.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c4d9e0a8368db90f93bd192bfa771ace63137c3488d198ee21dfb8e7771916e", size = 10190262 },
+    { url = "https://files.pythonhosted.org/packages/ea/19/a029cd335cf72f79d2644dcfc22d90f09caa86265cbbde3b5702ccef6890/numpy-2.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b0b5397374f32ec0649dd98c652a1798192042e715df918c20672c62fb52d4b8", size = 20987593 },
+    { url = "https://files.pythonhosted.org/packages/25/91/8ea8894406209107d9ce19b66314194675d31761fe2cb3c84fe2eeae2f37/numpy-2.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c5bdf2015ccfcee8253fb8be695516ac4457c743473a43290fd36eba6a1777eb", size = 14300523 },
+    { url = "https://files.pythonhosted.org/packages/a6/7f/06187b0066eefc9e7ce77d5f2ddb4e314a55220ad62dd0bfc9f2c44bac14/numpy-2.3.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d70f20df7f08b90a2062c1f07737dd340adccf2068d0f1b9b3d56e2038979fee", size = 5227993 },
+    { url = "https://files.pythonhosted.org/packages/e8/ec/a926c293c605fa75e9cfb09f1e4840098ed46d2edaa6e2152ee35dc01ed3/numpy-2.3.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:2fb86b7e58f9ac50e1e9dd1290154107e47d1eef23a0ae9145ded06ea606f992", size = 6736652 },
+    { url = "https://files.pythonhosted.org/packages/e3/62/d68e52fb6fde5586650d4c0ce0b05ff3a48ad4df4ffd1b8866479d1d671d/numpy-2.3.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:23ab05b2d241f76cb883ce8b9a93a680752fbfcbd51c50eff0b88b979e471d8c", size = 14331561 },
+    { url = "https://files.pythonhosted.org/packages/fc/ec/b74d3f2430960044bdad6900d9f5edc2dc0fb8bf5a0be0f65287bf2cbe27/numpy-2.3.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ce2ce9e5de4703a673e705183f64fd5da5bf36e7beddcb63a25ee2286e71ca48", size = 16693349 },
+    { url = "https://files.pythonhosted.org/packages/0d/15/def96774b9d7eb198ddadfcbd20281b20ebb510580419197e225f5c55c3e/numpy-2.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c4913079974eeb5c16ccfd2b1f09354b8fed7e0d6f2cab933104a09a6419b1ee", size = 15642053 },
+    { url = "https://files.pythonhosted.org/packages/2b/57/c3203974762a759540c6ae71d0ea2341c1fa41d84e4971a8e76d7141678a/numpy-2.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:010ce9b4f00d5c036053ca684c77441f2f2c934fd23bee058b4d6f196efd8280", size = 18434184 },
+    { url = "https://files.pythonhosted.org/packages/22/8a/ccdf201457ed8ac6245187850aff4ca56a79edbea4829f4e9f14d46fa9a5/numpy-2.3.1-cp313-cp313t-win32.whl", hash = "sha256:6269b9edfe32912584ec496d91b00b6d34282ca1d07eb10e82dfc780907d6c2e", size = 6440678 },
+    { url = "https://files.pythonhosted.org/packages/f1/7e/7f431d8bd8eb7e03d79294aed238b1b0b174b3148570d03a8a8a8f6a0da9/numpy-2.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:2a809637460e88a113e186e87f228d74ae2852a2e0c44de275263376f17b5bdc", size = 12870697 },
+    { url = "https://files.pythonhosted.org/packages/d4/ca/af82bf0fad4c3e573c6930ed743b5308492ff19917c7caaf2f9b6f9e2e98/numpy-2.3.1-cp313-cp313t-win_arm64.whl", hash = "sha256:eccb9a159db9aed60800187bc47a6d3451553f0e1b08b068d8b277ddfbb9b244", size = 10260376 },
+    { url = "https://files.pythonhosted.org/packages/e8/34/facc13b9b42ddca30498fc51f7f73c3d0f2be179943a4b4da8686e259740/numpy-2.3.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ad506d4b09e684394c42c966ec1527f6ebc25da7f4da4b1b056606ffe446b8a3", size = 21070637 },
+    { url = "https://files.pythonhosted.org/packages/65/b6/41b705d9dbae04649b529fc9bd3387664c3281c7cd78b404a4efe73dcc45/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:ebb8603d45bc86bbd5edb0d63e52c5fd9e7945d3a503b77e486bd88dde67a19b", size = 5304087 },
+    { url = "https://files.pythonhosted.org/packages/7a/b4/fe3ac1902bff7a4934a22d49e1c9d71a623204d654d4cc43c6e8fe337fcb/numpy-2.3.1-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:15aa4c392ac396e2ad3d0a2680c0f0dee420f9fed14eef09bdb9450ee6dcb7b7", size = 6817588 },
+    { url = "https://files.pythonhosted.org/packages/ae/ee/89bedf69c36ace1ac8f59e97811c1f5031e179a37e4821c3a230bf750142/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c6e0bf9d1a2f50d2b65a7cf56db37c095af17b59f6c132396f7c6d5dd76484df", size = 14399010 },
+    { url = "https://files.pythonhosted.org/packages/15/08/e00e7070ede29b2b176165eba18d6f9784d5349be3c0c1218338e79c27fd/numpy-2.3.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eabd7e8740d494ce2b4ea0ff05afa1b7b291e978c0ae075487c51e8bd93c0c68", size = 16752042 },
+    { url = "https://files.pythonhosted.org/packages/48/6b/1c6b515a83d5564b1698a61efa245727c8feecf308f4091f565988519d20/numpy-2.3.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e610832418a2bc09d974cc9fecebfa51e9532d6190223bc5ef6a7402ebf3b5cb", size = 12927246 },
+]
+
 [[package]]
 name = "packaging"
 version = "24.2"
@@ -1178,6 +1362,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/98/adc368fe369465f291ab24e18b9900473786ed1afdf861ba90467eb0767e/pytest_ordering-0.6-py3-none-any.whl", hash = "sha256:3f314a178dbeb6777509548727dc69edf22d6d9a2867bf2d310ab85c403380b6", size = 4643 },
 ]
 
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple/" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+]
+
 [[package]]
 name = "python-dotenv"
 version = "1.0.1"
@@ -1354,6 +1550,58 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a0/b9/1906bfeb30f2fc13bb39bf7ddb8749784c05faadbd18a21cf141ba37bff2/setuptools_scm-8.1.0-py3-none-any.whl", hash = "sha256:897a3226a6fd4a6eb2f068745e49733261a21f70b1bb28fce0339feb978d9af3", size = 43666 },
 ]
 
+[[package]]
+name = "shapely"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple/" }
+dependencies = [
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.3.1", source = { registry = "https://pypi.org/simple/" }, marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/3c/2da625233f4e605155926566c0e7ea8dda361877f48e8b1655e53456f252/shapely-2.1.1.tar.gz", hash = "sha256:500621967f2ffe9642454808009044c21e5b35db89ce69f8a2042c2ffd0e2772", size = 315422 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/fa/f18025c95b86116dd8f1ec58cab078bd59ab51456b448136ca27463be533/shapely-2.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d8ccc872a632acb7bdcb69e5e78df27213f7efd195882668ffba5405497337c6", size = 1825117 },
+    { url = "https://files.pythonhosted.org/packages/c7/65/46b519555ee9fb851234288be7c78be11e6260995281071d13abf2c313d0/shapely-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f24f2ecda1e6c091da64bcbef8dd121380948074875bd1b247b3d17e99407099", size = 1628541 },
+    { url = "https://files.pythonhosted.org/packages/29/51/0b158a261df94e33505eadfe737db9531f346dfa60850945ad25fd4162f1/shapely-2.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45112a5be0b745b49e50f8829ce490eb67fefb0cea8d4f8ac5764bfedaa83d2d", size = 2948453 },
+    { url = "https://files.pythonhosted.org/packages/a9/4f/6c9bb4bd7b1a14d7051641b9b479ad2a643d5cbc382bcf5bd52fd0896974/shapely-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c10ce6f11904d65e9bbb3e41e774903c944e20b3f0b282559885302f52f224a", size = 3057029 },
+    { url = "https://files.pythonhosted.org/packages/89/0b/ad1b0af491d753a83ea93138eee12a4597f763ae12727968d05934fe7c78/shapely-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:61168010dfe4e45f956ffbbaf080c88afce199ea81eb1f0ac43230065df320bd", size = 3894342 },
+    { url = "https://files.pythonhosted.org/packages/7d/96/73232c5de0b9fdf0ec7ddfc95c43aaf928740e87d9f168bff0e928d78c6d/shapely-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cacf067cdff741cd5c56a21c52f54ece4e4dad9d311130493a791997da4a886b", size = 4056766 },
+    { url = "https://files.pythonhosted.org/packages/43/cc/eec3c01f754f5b3e0c47574b198f9deb70465579ad0dad0e1cef2ce9e103/shapely-2.1.1-cp310-cp310-win32.whl", hash = "sha256:23b8772c3b815e7790fb2eab75a0b3951f435bc0fce7bb146cb064f17d35ab4f", size = 1523744 },
+    { url = "https://files.pythonhosted.org/packages/50/fc/a7187e6dadb10b91e66a9e715d28105cde6489e1017cce476876185a43da/shapely-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:2c7b2b6143abf4fa77851cef8ef690e03feade9a0d48acd6dc41d9e0e78d7ca6", size = 1703061 },
+    { url = "https://files.pythonhosted.org/packages/19/97/2df985b1e03f90c503796ad5ecd3d9ed305123b64d4ccb54616b30295b29/shapely-2.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:587a1aa72bc858fab9b8c20427b5f6027b7cbc92743b8e2c73b9de55aa71c7a7", size = 1819368 },
+    { url = "https://files.pythonhosted.org/packages/56/17/504518860370f0a28908b18864f43d72f03581e2b6680540ca668f07aa42/shapely-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9fa5c53b0791a4b998f9ad84aad456c988600757a96b0a05e14bba10cebaaaea", size = 1625362 },
+    { url = "https://files.pythonhosted.org/packages/36/a1/9677337d729b79fce1ef3296aac6b8ef4743419086f669e8a8070eff8f40/shapely-2.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aabecd038841ab5310d23495253f01c2a82a3aedae5ab9ca489be214aa458aa7", size = 2999005 },
+    { url = "https://files.pythonhosted.org/packages/a2/17/e09357274699c6e012bbb5a8ea14765a4d5860bb658df1931c9f90d53bd3/shapely-2.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:586f6aee1edec04e16227517a866df3e9a2e43c1f635efc32978bb3dc9c63753", size = 3108489 },
+    { url = "https://files.pythonhosted.org/packages/17/5d/93a6c37c4b4e9955ad40834f42b17260ca74ecf36df2e81bb14d12221b90/shapely-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b9878b9e37ad26c72aada8de0c9cfe418d9e2ff36992a1693b7f65a075b28647", size = 3945727 },
+    { url = "https://files.pythonhosted.org/packages/a3/1a/ad696648f16fd82dd6bfcca0b3b8fbafa7aacc13431c7fc4c9b49e481681/shapely-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d9a531c48f289ba355e37b134e98e28c557ff13965d4653a5228d0f42a09aed0", size = 4109311 },
+    { url = "https://files.pythonhosted.org/packages/d4/38/150dd245beab179ec0d4472bf6799bf18f21b1efbef59ac87de3377dbf1c/shapely-2.1.1-cp311-cp311-win32.whl", hash = "sha256:4866de2673a971820c75c0167b1f1cd8fb76f2d641101c23d3ca021ad0449bab", size = 1522982 },
+    { url = "https://files.pythonhosted.org/packages/93/5b/842022c00fbb051083c1c85430f3bb55565b7fd2d775f4f398c0ba8052ce/shapely-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:20a9d79958b3d6c70d8a886b250047ea32ff40489d7abb47d01498c704557a93", size = 1703872 },
+    { url = "https://files.pythonhosted.org/packages/fb/64/9544dc07dfe80a2d489060791300827c941c451e2910f7364b19607ea352/shapely-2.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2827365b58bf98efb60affc94a8e01c56dd1995a80aabe4b701465d86dcbba43", size = 1833021 },
+    { url = "https://files.pythonhosted.org/packages/07/aa/fb5f545e72e89b6a0f04a0effda144f5be956c9c312c7d4e00dfddbddbcf/shapely-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9c551f7fa7f1e917af2347fe983f21f212863f1d04f08eece01e9c275903fad", size = 1643018 },
+    { url = "https://files.pythonhosted.org/packages/03/46/61e03edba81de729f09d880ce7ae5c1af873a0814206bbfb4402ab5c3388/shapely-2.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78dec4d4fbe7b1db8dc36de3031767e7ece5911fb7782bc9e95c5cdec58fb1e9", size = 2986417 },
+    { url = "https://files.pythonhosted.org/packages/1f/1e/83ec268ab8254a446b4178b45616ab5822d7b9d2b7eb6e27cf0b82f45601/shapely-2.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:872d3c0a7b8b37da0e23d80496ec5973c4692920b90de9f502b5beb994bbaaef", size = 3098224 },
+    { url = "https://files.pythonhosted.org/packages/f1/44/0c21e7717c243e067c9ef8fa9126de24239f8345a5bba9280f7bb9935959/shapely-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e2b9125ebfbc28ecf5353511de62f75a8515ae9470521c9a693e4bb9fbe0cf1", size = 3925982 },
+    { url = "https://files.pythonhosted.org/packages/15/50/d3b4e15fefc103a0eb13d83bad5f65cd6e07a5d8b2ae920e767932a247d1/shapely-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4b96cea171b3d7f6786976a0520f178c42792897653ecca0c5422fb1e6946e6d", size = 4089122 },
+    { url = "https://files.pythonhosted.org/packages/bd/05/9a68f27fc6110baeedeeebc14fd86e73fa38738c5b741302408fb6355577/shapely-2.1.1-cp312-cp312-win32.whl", hash = "sha256:39dca52201e02996df02e447f729da97cfb6ff41a03cb50f5547f19d02905af8", size = 1522437 },
+    { url = "https://files.pythonhosted.org/packages/bc/e9/a4560e12b9338842a1f82c9016d2543eaa084fce30a1ca11991143086b57/shapely-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:13d643256f81d55a50013eff6321142781cf777eb6a9e207c2c9e6315ba6044a", size = 1703479 },
+    { url = "https://files.pythonhosted.org/packages/71/8e/2bc836437f4b84d62efc1faddce0d4e023a5d990bbddd3c78b2004ebc246/shapely-2.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3004a644d9e89e26c20286d5fdc10f41b1744c48ce910bd1867fdff963fe6c48", size = 1832107 },
+    { url = "https://files.pythonhosted.org/packages/12/a2/12c7cae5b62d5d851c2db836eadd0986f63918a91976495861f7c492f4a9/shapely-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1415146fa12d80a47d13cfad5310b3c8b9c2aa8c14a0c845c9d3d75e77cb54f6", size = 1642355 },
+    { url = "https://files.pythonhosted.org/packages/5b/7e/6d28b43d53fea56de69c744e34c2b999ed4042f7a811dc1bceb876071c95/shapely-2.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21fcab88b7520820ec16d09d6bea68652ca13993c84dffc6129dc3607c95594c", size = 2968871 },
+    { url = "https://files.pythonhosted.org/packages/dd/87/1017c31e52370b2b79e4d29e07cbb590ab9e5e58cf7e2bdfe363765d6251/shapely-2.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5ce6a5cc52c974b291237a96c08c5592e50f066871704fb5b12be2639d9026a", size = 3080830 },
+    { url = "https://files.pythonhosted.org/packages/1d/fe/f4a03d81abd96a6ce31c49cd8aaba970eaaa98e191bd1e4d43041e57ae5a/shapely-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:04e4c12a45a1d70aeb266618d8cf81a2de9c4df511b63e105b90bfdfb52146de", size = 3908961 },
+    { url = "https://files.pythonhosted.org/packages/ef/59/7605289a95a6844056a2017ab36d9b0cb9d6a3c3b5317c1f968c193031c9/shapely-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6ca74d851ca5264aae16c2b47e96735579686cb69fa93c4078070a0ec845b8d8", size = 4079623 },
+    { url = "https://files.pythonhosted.org/packages/bc/4d/9fea036eff2ef4059d30247128b2d67aaa5f0b25e9fc27e1d15cc1b84704/shapely-2.1.1-cp313-cp313-win32.whl", hash = "sha256:fd9130501bf42ffb7e0695b9ea17a27ae8ce68d50b56b6941c7f9b3d3453bc52", size = 1521916 },
+    { url = "https://files.pythonhosted.org/packages/12/d9/6d13b8957a17c95794f0c4dfb65ecd0957e6c7131a56ce18d135c1107a52/shapely-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:ab8d878687b438a2f4c138ed1a80941c6ab0029e0f4c785ecfe114413b498a97", size = 1702746 },
+    { url = "https://files.pythonhosted.org/packages/60/36/b1452e3e7f35f5f6454d96f3be6e2bb87082720ff6c9437ecc215fa79be0/shapely-2.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0c062384316a47f776305ed2fa22182717508ffdeb4a56d0ff4087a77b2a0f6d", size = 1833482 },
+    { url = "https://files.pythonhosted.org/packages/ce/ca/8e6f59be0718893eb3e478141285796a923636dc8f086f83e5b0ec0036d0/shapely-2.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4ecf6c196b896e8f1360cc219ed4eee1c1e5f5883e505d449f263bd053fb8c05", size = 1642256 },
+    { url = "https://files.pythonhosted.org/packages/ab/78/0053aea449bb1d4503999525fec6232f049abcdc8df60d290416110de943/shapely-2.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb00070b4c4860f6743c600285109c273cca5241e970ad56bb87bef0be1ea3a0", size = 3016614 },
+    { url = "https://files.pythonhosted.org/packages/ee/53/36f1b1de1dfafd1b457dcbafa785b298ce1b8a3e7026b79619e708a245d5/shapely-2.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d14a9afa5fa980fbe7bf63706fdfb8ff588f638f145a1d9dbc18374b5b7de913", size = 3093542 },
+    { url = "https://files.pythonhosted.org/packages/b9/bf/0619f37ceec6b924d84427c88835b61f27f43560239936ff88915c37da19/shapely-2.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b640e390dabde790e3fb947198b466e63223e0a9ccd787da5f07bcb14756c28d", size = 3945961 },
+    { url = "https://files.pythonhosted.org/packages/93/c9/20ca4afeb572763b07a7997f00854cb9499df6af85929e93012b189d8917/shapely-2.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:69e08bf9697c1b73ec6aa70437db922bafcea7baca131c90c26d59491a9760f9", size = 4089514 },
+    { url = "https://files.pythonhosted.org/packages/33/6a/27036a5a560b80012a544366bceafd491e8abb94a8db14047b5346b5a749/shapely-2.1.1-cp313-cp313t-win32.whl", hash = "sha256:ef2d09d5a964cc90c2c18b03566cf918a61c248596998a0301d5b632beadb9db", size = 1540607 },
+    { url = "https://files.pythonhosted.org/packages/ea/f1/5e9b3ba5c7aa7ebfaf269657e728067d16a7c99401c7973ddf5f0cf121bd/shapely-2.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8cb8f17c377260452e9d7720eeaf59082c5f8ea48cf104524d953e5d36d4bdb7", size = 1723061 },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
@@ -1395,6 +1643,11 @@ dependencies = [
     { name = "ujson" },
 ]
 
+[package.optional-dependencies]
+speckleifc = [
+    { name = "ifcopenshell" },
+]
+
 [package.dev-dependencies]
 dev = [
     { name = "commitizen" },
@@ -1417,8 +1670,9 @@ requires-dist = [
     { name = "appdirs", specifier = ">=1.4.4" },
     { name = "attrs", specifier = ">=24.3.0" },
     { name = "deprecated", specifier = ">=1.2.15" },
-    { name = "gql", extras = ["requests", "websockets"], specifier = ">=3.5.0" },
+    { name = "gql", extras = ["requests", "websockets"], specifier = ">=3.5.0,<4.0.0" },
     { name = "httpx", specifier = ">=0.28.1" },
+    { name = "ifcopenshell", marker = "extra == 'speckleifc'", specifier = ">=0.8.3.post2" },
     { name = "pydantic", specifier = ">=2.10.5" },
     { name = "pydantic-settings", specifier = ">=2.7.1" },
     { name = "ujson", specifier = ">=5.10.0" },