Added some troubleshooting measures to determine if another plugin is interfering with BB.

bump python version
bumping python version, so it works with our ubuntu latest image and `actions/setup-python@v2`
2026-08-09 09:21:46 +00:00 · 2022-12-13 08:12:21 -06:00 · 2022-12-13 21:35:42 +11:00 · 2022-12-11 22:49:44 +01:00 · 2022-12-11 22:46:05 +01:00 · 2022-12-10 19:45:17 +01:00
1863 changed files with 575338 additions and 122523 deletions
@@ -1,3 +1,4 @@
 # These are supported funding model platforms

 github: [aothms]
+open_collective: opensourcebim
@@ -0,0 +1,116 @@
+name: CD
+
+on: 
+  push:
+
+
+jobs:
+
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell' &&
+      !startsWith(github.event.head_commit.message, 'Release ') &&
+      !contains(github.event.head_commit.message, 'ci skip')
+    steps:
+    - run: echo ok go
+
+  build:
+    runs-on: ubuntu-20.04
+    needs: activate
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: recursive
+
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt-get install --no-install-recommends \
+        git cmake gcc g++ libboost-all-dev python3-all-dev swig libpcre3-dev libxml2-dev \
+        libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+        libhdf5-dev libcgal-dev
+
+    -
+      name: ccache
+      uses: hendrikmuhs/ccache-action@v1
+
+    - 
+      name: Build ifcopenshell
+      run: |
+        mkdir build && cd build
+        cmake \
+         -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+         -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+         -DCMAKE_INSTALL_PREFIX=$PWD/install/ \
+         -DCMAKE_BUILD_TYPE=Release \
+         -DCMAKE_PREFIX_PATH=/usr \
+         -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
+         -DBUILD_PACKAGE=On \
+         -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+         -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+         -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
+         -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
+         -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
+         -DCOLLADA_SUPPORT=Off \
+         -DLIBXML2_INCLUDE_DIR=/usr/include/libxml2 \
+         -DLIBXML2_LIBRARIES=/usr/lib/x86_64-linux-gnu/libxml2.so \
+         -DCGAL_INCLUDE_DIR=/usr/include \
+         -DGMP_INCLUDE_DIR=/usr/include \
+         -DMPFR_INCLUDE_DIR=/usr/include \
+         -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+         -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+         -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+         ../cmake
+        make -j $(nproc)
+        make install
+    - 
+      name: Package
+      run: |
+        make package
+      working-directory: build
+    - name: Upload 
+      uses: actions/upload-artifact@v2
+      with:
+        # Artifact name
+        name: ifcos-artifacts
+        # Directory containing files to upload
+        path: build/assets/Ifc*
+
+  deliver:
+    runs-on: ubuntu-20.04
+    needs: build
+    name: Docker Build, Tag, Push
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        lfs: true
+    
+    - name: Download 
+      uses: actions/download-artifact@v2
+      with:
+        # Artifact name
+        name: ifcos-artifacts
+        path: artifacts/
+    -
+      name: Set up QEMU
+      uses: docker/setup-qemu-action@v1
+    -
+      name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v1        
+    - 
+      name: Login to Dockerhub
+      uses: docker/login-action@v1 
+      with:
+        username: aecgeeks
+        password: ${{ secrets.DOCKER_HUB_TOKEN }}
+    - 
+      name: Build container image
+      uses: docker/build-push-action@v2
+      with: 
+        context: artifacts
+        repository: aecgeeks/ifcopenshell
+        tags: aecgeeks/ifcopenshell:latest
+        file: ./Dockerfile
+        push: true
@@ -0,0 +1,37 @@
+name: ci-bcf
+
+on:
+  push:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell' &&
+      contains(github.event.head_commit.message, '[bcf release]')
+    steps:
+      - run: echo ok go
+  upload:
+    needs: activate
+    name: Upload BCF package to Pypi
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.10'
+      - name: Build package
+        run: |
+          cd src/bcf
+          pip install build
+          python -m build
+      - name: Test
+        run: |
+          cd src/bcf
+          make test
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_TOKEN }}
+          packages_dir: src/bcf/dist
@@ -0,0 +1,92 @@
+name: Publish-blenderbim-chocolatey package
+
+on:
+  schedule:
+    #         ┌───────────── minute (0 - 59)
+    #         │  ┌───────────── hour (0 - 23)
+    #         │  │ ┌───────────── day of the month (1 - 31)
+    #         │  │ │ ┌───────────── month (1 - 12 or JAN-DEC)
+    #         │  │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
+    #         *  * * * *
+    - cron:  "30 0 * * *" # 30min past utc midnight
+
+env:
+  major: 0
+  minor: 0
+  name: blenderbim
+  choco_version: 1.1.0
+  CHOCO_TOKEN:   ${{ secrets.CHOCO_TOKEN }}
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [py310]
+        config:
+          - {
+            name: "Windows Build",
+            short_name: win,
+          }
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
+        with:
+          python-version: '3.10.9' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+      - run: echo ${{ env.DATE }}
+
+      - name: Check in published releases if we should do a choco release
+        id: do_choco
+        run: |
+          echo "::set-output name=choco_release::$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --do_choco_release?)"
+
+      - name: Fill chocolatey scripts on win with latest blender python
+        if: ${{steps.do_choco.outputs.choco_release}} == 'do_choco_release'
+        run: |
+          yesterday_non_iso="$(date  --date='yesterday' +'%y%m%d' | tr -d '\n')" &&
+          target_os=${{ matrix.config.short_name }} &&
+          latest_blender_python_version_maj_min=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_python_version_maj_min?) &&
+          echo "latest_blender_python_version_maj_min?: $latest_blender_python_version_maj_min" &&
+          pyver=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --pyver?) &&
+          export latest_blender_version_maj_min=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_release_maj_min?) &&
+          export latest_blender_version_maj_min_pat=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_release_maj_min_pat?) &&
+          echo   latest_blender_version_maj_min_pat?: $latest_blender_version_maj_min_pat &&
+          export blenderbim_build_version="${{ env.major }}.${{ env.minor }}.$yesterday_non_iso" &&
+          export url_blenderbim_py310_win_zip="https://github.com/IfcOpenShell/IfcOpenShell/releases/download/blenderbim-$yesterday_non_iso/blenderbim-$yesterday_non_iso-$pyver-$target_os.zip" &&
+          wget $url_blenderbim_py310_win_zip --no-verbose &&
+          export sha256sum_blenderbim_py310_win_zip=$( sha256sum blenderbim-$yesterday_non_iso-$pyver-$target_os.zip  --tag | cut -d ' ' -f 4  | tr -d '\n') &&
+          echo   sha256sum_blenderbim_py310_win_zip: $sha256sum_blenderbim_py310_win_zip &&
+          python3 choco/blenderbim/fill_dynamic_parameters.py &&
+          echo __build choco with mono &&
+          wget "https://github.com/chocolatey/choco/archive/refs/tags/$choco_version.tar.gz" --quiet &&
+          tar -xzf "$choco_version.tar.gz" &&
+          cd choco-$choco_version &&
+          chmod +x build.sh zip.sh &&
+          ./build.sh &&
+          cp -r build_output/chocolatey /opt/chocolatey &&
+          cd /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/ &&
+          echo __choco pack &&
+          mono /opt/chocolatey/choco.exe --version &&
+          mono /opt/chocolatey/choco.exe pack --allow-unofficial &&
+          echo __choco set apiKey &&
+          mono /opt/chocolatey/choco.exe setapikey --key="$CHOCO_TOKEN" --source="https://push.chocolatey.org/" --allow-unofficial # &&
+          echo __choco push &&
+          mono /opt/chocolatey/choco.exe push --source="https://push.chocolatey.org/" --key="$CHOCO_TOKEN" --allow-unofficial --verbose
+
+      - name: Inform user about not packaging
+        if: ${{steps.do_choco.outputs.choco_release}} != 'do_choco_release'
+        run: |
+          echo "no releases found today ${{ env.DATE }}, therefore choco packaging is skipped."
+
@@ -3,8 +3,20 @@ name: Publish-blenderbim-multiplatform
 on:
  push:
    paths:
-      - 'src/blenderbim/**'
      - '.github/workflows/ci-blenderbim-matrix.yml'
+      - 'src/blenderbim/**'
+      - 'src/ifcopenshell-python/ifcopenshell/**'
+      - 'src/bcf/src/bcf/**'
+      - 'src/ifcclash/ifcclash/**'
+      - 'src/ifccobie/**'
+      - 'src/ifcdiff/**'
+      - 'src/ifccsv/**'
+      - 'src/ifcpatch/ifcpatch/**'
+      - 'src/ifc4d/ifc4d/**'
+      - 'src/ifc5d/ifc5d/**'
+      - 'src/ifccityjson/**'
+    branches:
+      - v0.7.0

 env:
  major: 0
@@ -21,12 +33,13 @@ jobs:
      run: echo ok go

  build:
+    needs: activate
    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
-        pyver: [py37, py39]
+        pyver: [py37, py39, py310]
        config:
          - {
            name: "Windows Build",
@@ -40,11 +53,14 @@ jobs:
            name: "MacOS Build",
            short_name: macos
          }
+          - {
+            name: "MacOS ARM Build",
+            short_name: macosm1
+          }
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
        with:
-          python-version: '3.7.7' # Version range or exact version of a Python version to use, using SemVer's version range syntax
          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
      - run: echo ${{ env.DATE }}
      - name: Get current date
@@ -59,8 +75,8 @@ jobs:
        uses: svenstaro/upload-release-action@v2
        with:
          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: src/blenderbim_${{ matrix.config.short_name }}_${{ matrix.pyver }}/dist/blender28-bim-${{steps.date.outputs.date}}-${{ matrix.pyver }}-${{ matrix.config.short_name }}.zip
-          asset_name: blender28-bim-${{steps.date.outputs.date}}-${{ matrix.pyver }}-${{ matrix.config.short_name }}.zip
+          file: src/blenderbim_${{ matrix.config.short_name }}_${{ matrix.pyver }}/dist/blenderbim-${{steps.date.outputs.date}}-${{ matrix.pyver }}-${{ matrix.config.short_name }}.zip
+          asset_name: blenderbim-${{steps.date.outputs.date}}-${{ matrix.pyver }}-${{ matrix.config.short_name }}.zip
          tag: "blenderbim-${{steps.date.outputs.date}}"
          overwrite: true
          body: "Daily developer testing build blenderbim-${{steps.date.outputs.date}}"
@@ -0,0 +1,65 @@
+name: ci-ifcopenshell-conda-daily
+
+on:
+  workflow_run:
+    workflows: ["ci"]
+    types:
+      - completed
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+      - name: Set env
+        run: echo ok go
+
+  test:
+    name: ${{ matrix.platform.distver }}-${{ matrix.pyver.name }}
+    needs: activate
+    runs-on: ${{ matrix.platform.distver }}
+    defaults:
+      run:
+        shell: bash -l {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [
+          # { name: py39, distver: '3.9' },
+          { name: py310, distver: '3.10'},
+          { name: py311, distver: '3.11'}
+        ]
+        platform: [
+          { name: Windows, distver: windows-2022, upload: 'false' },
+          { name: Windows, distver: windows-2019, upload: 'true' },
+          { name: Linux, distver: ubuntu-20.04,  upload: 'true' },
+          { name: Linux, distver: ubuntu-22.04,  upload: 'false' },
+          { name: macOS, distver: macos-11, upload: 'true' },
+          { name: macOS, distver: macos-12, upload: 'false' }
+        ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Download MacOSX SDK
+        if: ${{ matrix.platform.name == 'macOS' }}
+        run: |
+          curl -o MacOSX10.13.sdk.tar.xz -L https://github.com/phracker/MacOSX-SDKs/releases/download/11.3/MacOSX10.13.sdk.tar.xz && \
+          tar xf MacOSX10.13.sdk.tar.xz && \
+          sudo mv -v MacOSX10.13.sdk /opt/ && \
+          ls /opt/
+      - uses: seanmiddleditch/gha-setup-ninja@master
+      - uses: conda-incubator/setup-miniconda@v2  # https://github.com/conda-incubator/setup-miniconda
+        with:
+          activate-environment: conda-build
+          python-version: ${{ matrix.pyver.distver }}
+          environment-file: conda/environment.yml
+      - name: build, test and upload ifcopenshell
+        if: ${{ matrix.platform.upload == 'true' }}
+        run: |
+          conda-build . --python ${{ matrix.pyver.distver }} -c conda-forge --token ${{ secrets.ANACONDA_TOKEN }} --user ifcopenshell --no-remove-work-dir
+      - name: build & test ifcopenshell
+        if: ${{ matrix.platform.upload == 'false' }}
+        run: |
+          conda-build . --python ${{ matrix.pyver.distver }} -c conda-forge --no-remove-work-dir
@@ -0,0 +1,73 @@
+name: ci-ifcopenshell-pypi
+
+on:
+  schedule:
+    #         ┌───────────── minute (0 - 59)
+    #         │  ┌───────────── hour (0 - 23)
+    #         │  │ ┌───────────── day of the month (1 - 31)
+    #         │  │ │ ┌───────────── month (1 - 12 or JAN-DEC)
+    #         │  │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
+    #         *  * * * *
+    - cron: "49 23 1 * *" # 11min before utc midnight
+
+env:
+  major: 0
+  minor: 0
+  name: ifcopenshell
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [py36, py37, py38, py39, py310]
+        config:
+          - {
+            name: "Windows Build",
+            short_name: win,
+          }
+          - {
+            name: "Linux Build",
+            short_name: linux
+          }
+          - {
+            name: "MacOS Build",
+            short_name: macos
+          }
+          - {
+            name: "MacOS ARM Build",
+            short_name: macosm1
+          }
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
+        with:
+          python-version: '3.7.7' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+      - run: echo ${{ env.DATE }}
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%y%m%d')"
+      - name: Compile
+        run: |
+          pip install build
+          cp -r src/ifcopenshell-python src/ifcopenshell_${{ matrix.config.short_name }}_${{ matrix.pyver }} &&
+          cd src/ifcopenshell_${{ matrix.config.short_name }}_${{ matrix.pyver }} &&
+          make dist PLATFORM=${{ matrix.config.short_name }} PYVERSION=${{ matrix.pyver }}
+      - name: Publish a Python distribution to PyPI
+        uses: ortega2247/pypi-upload-action@master
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: src/ifcopenshell_${{ matrix.config.short_name }}_${{ matrix.pyver }}/dist
@@ -0,0 +1,95 @@
+name: ci_py_only
+
+on:
+  push:
+    paths:
+      - 'src/**'
+      - 'test/**'
+      - 'conda/**'
+      - 'cmake/**'
+      - '.github/workflows/ci_py_only.yml'
+  pull_request:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell' &&
+      !contains(github.event.head_commit.message, 'skip ci')
+    steps:
+      - run: echo ok go
+
+  build:
+    runs-on: ubuntu-20.04
+    needs: activate
+    steps:
+      - uses: actions/checkout@v2
+        with:
+            submodules: recursive
+      - name: Install C++ dependencies
+        run: |
+          sudo apt update
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev
+          
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1
+
+      - name: Build ifcopenshell
+        run: |
+          mkdir build && cd build
+          cmake \
+               -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_BUILD_TYPE=Release \
+               -DCMAKE_PREFIX_PATH=/usr \
+               -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
+               -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+               -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
+               -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
+               -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
+               -DCOLLADA_SUPPORT=Off \
+               "-DSCHEMA_VERSIONS=2x3;4" \
+               -DBUILD_CONVERT=Off \
+               -DGLTF_SUPPORT=On \
+               -DJSON_INCLUDE_DIR=/usr/include \
+               -DCGAL_INCLUDE_DIR=/usr/include \
+               -DGMP_INCLUDE_DIR=/usr/include \
+               -DMPFR_INCLUDE_DIR=/usr/include \
+               -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+             ../cmake
+          sudo make -j $(nproc)
+          sudo make install
+
+      - name: Install Python dependencies
+        run: |
+          sudo /usr/bin/python -m pip install -U pip
+          sudo /usr/bin/python -m pip install xmlschema numpy lxml
+          sudo /usr/bin/python -m pip install src/bcf
+          sudo /usr/bin/python -m pip install pytest
+          sudo /usr/bin/python -m pip install isodate
+          sudo /usr/bin/python -m pip install lark
+          sudo /usr/bin/python -m pip install networkx
+
+      - name: Test
+        run: |
+          cd test
+          sudo /usr/bin/python tests.py
+          cd ../src/ifcopenshell-python
+          mv ifcopenshell ifcopenshell-local # Force testing on installed module
+          make test
@@ -1,107 +1,105 @@
-name: CI
+name: ci

-on: 
+on:
  push:
-
+    paths:
+      - 'src/ifcblender/**'
+      - 'src/ifcconvert/**'
+      - 'src/ifcgeom/**'
+      - 'src/ifcgeom_schema_agnostic/**'
+      - 'src/ifcgeomserver/**'
+      - 'src/ifcjni/**'
+      - 'src/ifcmax/**'
+      - 'src/ifcopenshell-python/**'
+      - '!src/ifcopenshell-python/docs/**'
+      - 'src/ifcparse/**'
+      - 'src/ifcwrap/**'
+      - 'src/qtviewer/**'
+      - 'src/serializers/**'
+      - 'conda/**'
+      - 'cmake/**'
+      - '.github/workflows/ci.yml'
+  pull_request:

 jobs:
-
  activate:
    runs-on: ubuntu-latest
    if: |
      github.repository == 'IfcOpenShell/IfcOpenShell' &&
-      !startsWith(github.event.head_commit.message, 'Release ') &&
-      !contains(github.event.head_commit.message, 'ci skip')
+      !contains(github.event.head_commit.message, 'skip ci')
    steps:
-    - run: echo ok go
+      - run: echo ok go

  build:
    runs-on: ubuntu-20.04
    needs: activate
    steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v2
+        with:
+            submodules: recursive
+      - name: Install C++ dependencies
+        run: |
+          sudo apt update
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev
+          
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1

-    - name: Install dependencies
-      run: |
-        sudo apt update
-        sudo apt-get install --no-install-recommends \
-        git cmake gcc g++ libboost1.67-all-dev python3-all-dev swig libpcre3-dev libxml2-dev \
-        liboce-foundation-dev liboce-modeling-dev liboce-ocaf-dev liboce-visualization-dev liboce-ocaf-lite-dev
+      - name: Build ifcopenshell
+        run: |
+          mkdir build && cd build
+          cmake \
+               -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_BUILD_TYPE=Release \
+               -DCMAKE_PREFIX_PATH=/usr \
+               -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
+               -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+               -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
+               -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
+               -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
+               -DCOLLADA_SUPPORT=Off \
+               "-DSCHEMA_VERSIONS=2x3;4;4x3" \
+               -DGLTF_SUPPORT=On \
+               -DJSON_INCLUDE_DIR=/usr/include \
+               -DCGAL_INCLUDE_DIR=/usr/include \
+               -DGMP_INCLUDE_DIR=/usr/include \
+               -DMPFR_INCLUDE_DIR=/usr/include \
+               -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+             ../cmake
+          sudo make -j $(nproc)
+          sudo make install

-    -
-      name: ccache
-      uses: hendrikmuhs/ccache-action@v1
+      - name: Install Python dependencies
+        run: |
+          sudo /usr/bin/python -m pip install -U pip
+          sudo /usr/bin/python -m pip install xmlschema numpy lxml
+          sudo /usr/bin/python -m pip install src/bcf
+          sudo /usr/bin/python -m pip install pytest
+          sudo /usr/bin/python -m pip install isodate
+          sudo /usr/bin/python -m pip install lark
+          sudo /usr/bin/python -m pip install networkx

-    - 
-      name: Build ifcopenshell
-      run: |
-        mkdir build && cd build
-        cmake \
-         -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-         -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-         -DCMAKE_INSTALL_PREFIX=$PWD/install/ \
-         -DCMAKE_BUILD_TYPE=Release \
-         -DCMAKE_PREFIX_PATH=/usr \
-         -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
-         -DBUILD_PACKAGE=On \
-         -DOCC_INCLUDE_DIR=/usr/include/oce \
-         -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
-         -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
-         -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
-         -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
-         -DCOLLADA_SUPPORT=Off \
-         -DLIBXML2_INCLUDE_DIR=/usr/include/libxml2 \
-         -DLIBXML2_LIBRARIES=/usr/lib/x86_64-linux-gnu/libxml2.so \
-         ../cmake
-        make -j $(nproc)
-        make install
-    - 
-      name: Package
-      run: |
-        make package
-      working-directory: build
-    - name: Upload 
-      uses: actions/upload-artifact@v2
-      with:
-        # Artifact name
-        name: ifcos-artifacts
-        # Directory containing files to upload
-        path: build/assets/Ifc*
-
-  deliver:
-    runs-on: ubuntu-20.04
-    needs: build
-    name: Docker Build, Tag, Push
-
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        lfs: true
-    
-    - name: Download 
-      uses: actions/download-artifact@v2
-      with:
-        # Artifact name
-        name: ifcos-artifacts
-        path: artifacts/
-    -
-      name: Set up QEMU
-      uses: docker/setup-qemu-action@v1
-    -
-      name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v1        
-    - 
-      name: Login to Dockerhub
-      uses: docker/login-action@v1 
-      with:
-        username: aecgeeks
-        password: ${{ secrets.DOCKER_HUB_TOKEN }}
-    - 
-      name: Build container image
-      uses: docker/build-push-action@v2
-      with: 
-        context: artifacts
-        repository: aecgeeks/ifcopenshell
-        tags: aecgeeks/ifcopenshell:latest
-        file: ./Dockerfile
-        push: true
+      - name: Test
+        run: |
+          cd test
+          sudo /usr/bin/python tests.py
+          cd ../src/ifcopenshell-python
+          mv ifcopenshell ifcopenshell-local # Force testing on installed module
+          make test
@@ -18,13 +18,25 @@ jobs:
      - name: Checkout
        uses: actions/checkout@v2
        with:
-          lfs: true
-      - 
-        name: Update ubuntu
+          submodules: recursive
+      - name: Install C++ dependencies
        run: |
          sudo apt update
-          sudo apt-get install git cmake gcc g++ libboost1.67-all-dev python3-all-dev swig libpcre3-dev libxml2-dev
-          sudo apt-get install liboce-foundation-dev liboce-modeling-dev liboce-ocaf-dev liboce-visualization-dev liboce-ocaf-lite-dev
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev opencollada-dev
+          
      - name: Build
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -37,14 +49,23 @@ jobs:
           -DCMAKE_PREFIX_PATH=/usr \
           -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
           -DBUILD_PACKAGE=On \
-           -DOCC_INCLUDE_DIR=/usr/include/oce \
+           -DOCC_INCLUDE_DIR=/usr/include/opencascade \
           -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
           -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
           -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
           -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
-           -DCOLLADA_SUPPORT=Off \
           -DLIBXML2_INCLUDE_DIR=/usr/include/libxml2 \
           -DLIBXML2_LIBRARIES=/usr/lib/x86_64-linux-gnu/libxml2.so \
+           -DGLTF_SUPPORT=On \
+           -DJSON_INCLUDE_DIR=/usr/include \
+           -DCGAL_INCLUDE_DIR=/usr/include \
+           -DGMP_INCLUDE_DIR=/usr/include \
+           -DMPFR_INCLUDE_DIR=/usr/include \
+           -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+           -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+           -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+           -DOPENCOLLADA_INCLUDE_DIR=/usr/include/opencollada \
+           -DOPENCOLLADA_LIBRARY_DIR=/usr/lib/opencollada/ \
           ../cmake
          make -j $(nproc)
          make install
@@ -1,14 +1,19 @@
 # Dependency and build folders created by the build scripts
-/_build-vs2015-x64/
-/_deps-vs2015-x64-installed/
-/_build-vs2017-x64/
-/_deps-vs2017-x64-installed/
-/_build-vs2019-x64/
-/_deps-vs2019-x64-installed/
 /_deps/
-/deps*/
-/build*/
-/install*/
+/_build-vs*-x*/
+/_deps-vs*-x*-installed/
+/_installed-vs*-x*/
+/build/
+
+# output directories
+/cmake/out/
+/docs/out/
+/src/examples/out/
+/src/ifcmax/out/
+/src/ifcwrap/out/
+/src/qtviewer/out/
+
+
 /win/BuildDepsCache*.txt
 # IfcExpressParser residue
 /src/ifcexpressparser/express_parser.py
@@ -17,6 +22,7 @@ __pycache__
 *.py.bak
 # Visual Studio Code files
 .vscode
+.vs
 # PyCharm files
 .idea

@@ -32,7 +38,52 @@ Pipfile.lock

 # gettext binary translation files
 *.mo
+
 # Vim
 *.swp
+*.swo

+# Flask
+instance/*
+!instance/.gitignore
+.webassets-cache
+.env
+*.db

+# Byte-compiled / optimized / DLL files
+*.py[cod]
+*$py.class
+
+# pipenv
+Pipfile
+Pipfile.lock
+
+# Database
+*.db
+
+# PyTest
+htmlcov
+.coverage
+
+# Blender
+*.blend1
+
+# Sphinx
+_build/
+
+# IDS Docs
+src/ifcopenshell-python/test/build
+
+# tox cache
+.tox/
+*.egg-info/
+
+# mypy cache
+.mypy_cache
+
+# blenderbim libs
+src/blenderbim/blenderbim/libs
+
+# ifcopenshell swig and compiled files
+src/ifcopenshell-python/ifcopenshell/_ifcopenshell_wrapper.so
+src/ifcopenshell-python/ifcopenshell/ifcopenshell_wrapper.py
@@ -5,3 +5,9 @@
 [submodule "src/ifcopenshell-python/ifcopenshell/mvd"]
 	path = src/ifcopenshell-python/ifcopenshell/mvd
 	url = https://github.com/opensourceBIM/python-mvdxml/
+[submodule "src/svgfill"]
+	path = src/svgfill
+	url = https://github.com/IfcOpenShell/svgfill
+[submodule "src/ifcopenshell-python/test/Sample-BIM-Files"]
+	path = src/ifcopenshell-python/test/Sample-BIM-Files
+	url = https://github.com/IfcOpenShell/ids-test-files
@@ -24,6 +24,7 @@ addons:
    - python3-all-dev
    - python3-pip
    - swig
+    - libhdf5-dev

 before_script:
  - if [ $TRAVIS_OS_NAME == "linux" ]; then ccache -z; fi
@@ -47,6 +48,7 @@ script:
    "-DSCHEMA_VERSIONS=2x3;4" \
    -DGLTF_SUPPORT=On \
    -DJSON_INCLUDE_DIR=/usr/include \
+    -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
    ../cmake

  # TODO: Drop sudo
@@ -1,7 +1,7 @@
                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ 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.

@@ -618,4 +618,4 @@ 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
+                     END OF TERMS AND CONDITIONS
@@ -1,7 +1,7 @@
                   GNU LESSER GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ 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.

@@ -23,9 +23,11 @@ RUN echo "deb http://archive.ubuntu.com/ubuntu focal-proposed main restricted" |
    echo "deb http://archive.ubuntu.com/ubuntu focal-proposed multiverse" |  tee -a /etc/apt/sources.list; \
    apt-get -qq update; \
    apt-get -y install tzdata dos2unix rsync; \
-    apt-get -y install python3 libxml2 liboce-foundation11 liboce-modeling11 liboce-ocaf11 liboce-visualization11 \
-                     liboce-ocaf-lite11 libpython3.8 libboost-system1.67.0 libboost-program-options1.67.0 \
-                    libboost-regex1.67.0 libboost-thread1.67.0 libboost-date-time1.67.0; \
+    apt-get -y install python3 libxml2 libpython3.8 \
+                    libboost-all-dev \
+                    libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev \
+                    libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+                    libhdf5-serial-dev ; \
    rm -rf /var/lib/apt/lists/* ; 

 COPY . /home/IfcOpenShell/
@@ -1,223 +1,76 @@
+
 IfcOpenShell 
 ============
-IfcOpenShell is an open source ([LGPL]) software library for working with the Industry Foundation Classes ([IFC]) 
-file format. Currently supported IFC releases are [IFC2x3 TC1] and [IFC4 Add2 TC1].

-For more information, see
-* [http://ifcopenshell.org](http://ifcopenshell.org)  
-* [http://academy.ifcopenshell.org](http://academy.ifcopenshell.org)
+IfcOpenShell is an open source ([LGPL]) software library for working with Industry Foundation Classes ([IFC]). Complete
+parsing support is provided for [IFC2x3 TC1], [IFC4 Add2 TC1], IFC4x1, IFC4x3, and IFC4x3. Extensive geometric support
+is implemented for the IFC releases [IFC2x3 TC1] and [IFC4 Add2 TC1]. Extending with support for arbitrary IFC schemas
+is possible at compile-time when using C++ and at run-time when using Python.

-[![Build Status](https://travis-ci.org/IfcOpenShell/IfcOpenShell.svg?branch=v0.6.0)](https://travis-ci.org/IfcOpenShell/IfcOpenShell)
+In addition to a C++ and Python API, IfcOpenShell comes with an ecosystem of tools, notably including IfcConvert (an application to convert IFC models to
+other formats), the BlenderBIM Add-on (an add-on to Blender providing a graphical IFC authoring platform), and many
+other libraries, CLI apps, and more. Support is also provided for auxiliary standards such as BCF and IDS.

-Prerequisites
-------------
-* Git
-* CMake (2.6 or newer)
-* Windows: [Visual Studio] 2008 or newer with C++ toolset (or [Visual C++ Build Tools]) or [MSYS2] + MinGW
-* *nix: GCC 4.7 or newer, or Clang (any version)
+For more information, see:

-Dependencies
-------------
-* [Boost](http://www.boost.org/)
-* [Open Cascade](https://dev.opencascade.org/) - *optional*, but required for building IfcGeom
-  ([official](https://dev.opencascade.org/release), "OCCT", or [community edition](https://github.com/tpaviot/oce), "OCE")  
-  For converting IFC representation items into BRep solids and tesselated meshes
-* [OpenCOLLADA](https://github.com/khronosGroup/OpenCOLLADA/) - *optional*  
-  For IfcConvert to be able to write tessellated Collada (.dae) files
-* [SWIG](http://www.swig.org/) and [Python](https://www.python.org/) - *optional*  
-  For building the IfcOpenShell Python interface and the Blender add-on
-* [3ds Max SDK](http://www.autodesk.com/products/3ds-max/free-trial) - *optional*  
-  For building the 3ds Max plug-in.
-  All recent versions of 3ds Max (2014 and newer) are 64-bit only, so a 64-bit installation is assumed.
+* [IfcOpenShell Website](http://ifcopenshell.org)
+* [IfcOpenShell Documentation](http://blenderbim.org/docs-python)
+  * [IfcOpenShell C++ Installation](https://blenderbim.org/docs-python/ifcopenshell/installation.html)
+  * [IfcOpenShell Python Installation](https://blenderbim.org/docs-python/ifcopenshell-python/installation.html)
+  * [IfcOpenShell Python Hello World Tutorial](https://blenderbim.org/docs-python/ifcopenshell-python/hello_world.html)
+* [BlenderBIM Add-on Website](https://blenderbim.org)
+* [BlenderBIM Add-on Documentation](http://blenderbim.org/docs)
+  * [Add-on Installation](https://blenderbim.org/docs/users/installation.html)
+  * [Exploring an IFC model](https://blenderbim.org/docs/users/exploring_an_ifc_model.html)

-Building IfcOpenShell
---------------------
+| Service                                         | Status                                                                                                                                       |
+| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| Anaconda Daily Build                            | [![Anaconda-Server Badge](https://img.shields.io/conda/vn/ifcopenshell/ifcopenshell)](https://anaconda.org/ifcopenshell/ifcopenshell)        |
+| Anaconda v0.7.0 Stable                          | [![Anaconda-Server Badge](https://img.shields.io/conda/vn/conda-forge/ifcopenshell)](https://anaconda.org/conda-forge/ifcopenshell)          |
+| PyPi Daily Build                                | [![PyPi Badge](https://img.shields.io/pypi/v/ifcopenshell)](https://pypi.org/project/ifcopenshell/)                                          |
+| ArchLinux AUR Package Stable                           | [![AUR Badge](https://img.shields.io/aur/version/ifcopenshell)](https://aur.archlinux.org/packages/ifcopenshell)                     |
+| ArchLinux AUR Package git                           | [![AUR Badge](https://img.shields.io/aur/version/ifcopenshell-git)](https://aur.archlinux.org/packages/ifcopenshell-git)                     |
+| BlenderBIM Add-on Chocolatey (under moderation) | [![Chocolatey Badge](https://img.shields.io/chocolatey/v/blenderbim-nightly)](https://community.chocolatey.org/packages/blenderbim-nightly/) |
+| Sponsor development on OpenCollective           | [![Financial Contributors](https://opencollective.com/opensourcebim/tiers/badge.svg)](https://opencollective.com/opensourcebim/)             |
+| Docker hub                                      | [![Docker Pulls](https://img.shields.io/docker/pulls/aecgeeks/ifcopenshell)](https://hub.docker.com/r/aecgeeks/ifcopenshell)                 |

-**Note:** The path where the source code is cloned to can contain spaces but non-ASCII characters are very likely to cause problems with the build.
+Contents
+--------

-### Compiling on Windows
-The preferred way to fetch and build this project's dependencies is to use the build scripts
-in win/ folder. **See [win/readme.md] for more information**.
+Those marked with an asterisk are part of IfcOpenShell.

-#### Using Visual Studio
-Instructions in a nutshell (**assuming Visual Studio 2015 x64 environment variables set**):
+| Name                      | Description                                                           | License             |
+| ------------------------- | ----------------------------------------------------------------------| ------------------- |
+| bcf                       | Library to read and write BCF-XML and query OpenCDE BCF-API modules   | LGPL-3.0-or-later   |
+| blenderbim                | Add-on to Blender providing a graphical native IFC authoring platform | GPL-3.0-or-later    |
+| bsdd                      | Library to query the bSDD API                                         | LGPL-3.0-or-later   |
+| ifc2ca                    | Utility to convert IFC structural analysis models to Code_Aster       | LGPL-3.0-or-later   |
+| ifc4d                     | Convert to and from IFC and project management software               | LGPL-3.0-or-later   |
+| ifc5d                     | Report and optimise cost information from IFC                         | LGPL-3.0-or-later   |
+| ifcbimtester              | Wrapper for Gherkin based unit testing for IFC models                 | LGPL-3.0-or-later   |
+| ifcblender                | Historic Blender IFC import add-on                                    | LGPL-3.0-or-later\* |
+| ifccityjson               | Convert CityJSON to IFC                                               | LGPL-3.0-or-later   |
+| ifcclash                  | Clash detection library and CLI app                                   | LGPL-3.0-or-later   |
+| ifccobie                  | Extract IFC data for COBie handover requirements                      | LGPL-3.0-or-later   |
+| ifcconvert                | CLI app to convert IFC to many other formats                          | LGPL-3.0-or-later\* |
+| ifccsv                    | Library and CLI app to export and import schedules from IFC           | LGPL-3.0-or-later   |
+| ifcdiff                   | Compare changes between IFC models                                    | LGPL-3.0-or-later   |
+| ifcfm                     | Extract IFC data for FM handover requirements                         | LGPL-3.0-or-later   |
+| ifcgeom                   | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcgeom\_schema\_agnostic | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcgeomserver             | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcjni                    | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcmax                    | Historic extension for IFC support in 3DS Max                         | LGPL-3.0-or-later\* |
+| ifcopenshell-python       | Python library for IFC manipulation                                   | LGPL-3.0-or-later\* |
+| ifcparse                  | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| ifcpatch                  | Utility to run pre-packaged scripts to manipulate IFCs                | LGPL-3.0-or-later   |
+| ifcsverchok               | Blender Add-on for visual node programming with IFC                   | GPL-3.0-or-later    |
+| ifctester                 | Library, CLI and webapp for IDS model auditing                        | LGPL-3.0-or-later   |
+| ifcwrap                   | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| qtviewer                  | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |
+| serializers               | Internal library for IfcOpenShell                                     | LGPL-3.0-or-later\* |

-    > cd IfcOpenShell\win
-    > build-deps.cmd
-    > run-cmake.bat
-
-NB: `build-deps.cmd` need to be ran from the directory containing it, i.e. the `./win` folder.
-
-You can now open and build the solution file in Visual Studio:
-
-    > ..\build-vs2015-x64\IfcOpenShell.sln
-
-As the scripts default to using the `RelWithDebInfo` configuration, and a freshly created solution by CMake defaults
-to `Debug`, make sure to switch the used build configuration. Build the `INSTALL` project (right-click -> Project
-Only) to deploy the headers and binaries into a single location if wanted/needed.
-
-Alternatively, one can use the utility batch file(s) to build and install the project easily from the command-line
-(installing a project will build it also, if required):
-
-    > install-ifcopenshell.bat
-
-#### Using MSYS2 + MinGW
-
-Start the MSYS2 Shell and then:
-
-    $ cd IfcOpenShell/win
-    $ ./build-deps.sh
-    $ ./run-cmake.sh
-    $ ./install-ifcopenshell.sh
-
-#### Using Bash on Ubuntu on Windows
-
-Start Bash on Ubuntu on Windows and follow the instructions below. Compiling on Ubuntu 14.04.4 LTS using GCC 4.8.4
-or Clang 3.5 has been confirmed to work.
-
-### Compiling on *nix
-
-The following instructions are for Ubuntu, modify as required for other operating systems. [nix/build-all.py] script
-can be experimented with and studied for pointers for other operating systems, but note that this script is not currently
-meant to be used for a typical IfcOpenShell workspace setup.
-
-Note: where `make -j` is written, add a number roughly equal to the amount of CPU cores + 1.
-
-**1)** Install most of the prerequisites and dependencies:
-
-    $ sudo apt-get install git cmake gcc g++ libboost-all-dev
-
-**2a)** Either use an OCE package from your operating system's software repository
-
-    $ sudo apt-get install liboce-foundation-dev liboce-modeling-dev liboce-ocaf-dev liboce-visualization-dev liboce-ocaf-lite-dev
-
-**2b)** or (if not available, or the latest code is wanted) compile OCE yourself (note that the build takes a long time):
-
-    $ sudo apt-get install libftgl-dev libtbb2 libtbb-dev libgl1-mesa-dev libfreetype6-dev
-    $ git clone https://github.com/tpaviot/oce.git
-    $ cd oce
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make -j
-    $ sudo make install
-
-**2c)** or obtain and compile OCCT from https://dev.opencascade.org/release
-
-**3)** For building IfcConvert with COLLADA (.dae) support (on by default), OpenCOLLADA is needed:
-
-    $ sudo apt-get install libpcre3-dev libxml2-dev
-    $ git clone https://github.com/KhronosGroup/OpenCOLLADA.git
-    $ cd OpenCOLLADA
-    Using a known good revision, but HEAD should work too:
-    $ git checkout 064a60b65c2c31b94f013820856bc84fb1937cc6
-    $ mkdir build && cd build
-    $ cmake ..
-    $ make -j
-    $ sudo make install
-
-**4)** For building the IfcPython wrapper (on by default), SWIG and Python development are needed, if not already available:
-
-    $ sudo apt-get install python-all-dev swig
-
-**5)** To build IfcOpenShell please take the following steps. Alternatively use environment variables for setting the
-dependencies' paths. `OCC_INCLUDE_DIR` might be needed to set also. `OPENCOLLADA_INCLUDE_DIR` and `OPENCOLLADA_LIBRARY_DIR`
-(and potentially `PCRE_LIBRARY_DIR`) are needed if building with COLLADA support. (`-DCOLLADA_SUPPORT=0` disables it).
-
-    $ cd /path/to/IfcOpenShell
-    $ mkdir build && cd build
-    $ cmake ../cmake -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu/ \
-          -DOPENCOLLADA_INCLUDE_DIR="/usr/local/include/opencollada" \
-          -DOPENCOLLADA_LIBRARY_DIR="/usr/local/lib/opencollada"  \
-          -DPCRE_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu/
-    $ make -j
-
-If all worked out correctly you can now use IfcOpenShell. See the examples below.
-
-**6)** Install the project if wanted:
-
-    $ sudo make install
-
-Installing IfcOpenShell with Conda
----------------------------------
-Another option for building and installing IfcOpenShell is to use the popular
-[Anaconda Python Distribution](https://www.anaconda.com/download).
-The requirements are spread across a number of channels.
-You can add these channels to your configuration, or specify them all on the command line:
-
-    $ conda install -c conda-forge -c oce -c dlr-sc -c ifcopenshell ifcopenshell
-
-Usage examples
--------------
-
-**Invoking IfcConvert from the command line**
-
-    $ wget ftp://ftp.dds.no/pub/ifc/Munkerud/Munkerud_hus6_BE.zip
-    $ unzip Munkerud_hus6_BE.zip
-    $ ./IfcConvert Munkerud_hus6_BE.ifc
-    $ less Munkerud_hus6_BE.obj
-
-**Using the IfcOpenShell Python interface**
-
-    $ wget -O duplex.zip https://portal.nibs.org/files/wl/?id=4DsTgHFQAcOXzFetxbpRCECPbbfUqpgo
-    $ unzip duplex.zip
-    $ python
-    >>> import ifcopenshell
-    >>> f = ifcopenshell.open("Duplex_A_20110907_optimized.ifc")
-    >>>
-    >>> # Accessing entity instances by type:
-    >>> f.by_type("ifcwall")[:2]
-    [#91=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FL9r',#1,'Basic Wall:Interior - Partition (92mm Stud):144586',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5198,#18806,'144586'), #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')]
-    >>> wall = _[0]
-    >>> len(wall) # number of EXPRESS attributes
-    8
-    >>>
-    >>> # Accessing EXPRESS attributes by name:
-    >>> wall.GlobalId 
-    '2O2Fr$t4X7Zf8NOew3FL9r'
-    >>> wall.Name = "My wall"
-    >>> wall.NonExistingAttr
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in <module>
-      File ".\ifcopenshell.py", line 14, in __getattr__
-        except: raise AttributeError("entity instance of type '%s' has no attribute'%s'"%(self.wrapped_data.is_a(), name)) from None
-    AttributeError: entity instance of type 'IfcWallStandardCase' has no attribute 'NonExistingAttr'
-    >>> wall.GlobalId = 3
-    Traceback (most recent call last):
-      File "<stdin>", line 1, in <module>
-      File ".\ifcopenshell.py", line 26, in __setattr__
-        self[self.wrapped_data.get_argument_index(key)] = value
-      File ".\ifcopenshell.py", line 30, in __setitem__
-        self.wrapped_data.set_argument(idx, entity_instance.map_value(value))
-      File ".\ifc_wrapper.py", line 118, in <lambda>
-        set_argument = lambda self,x,y: self._set_argument(x) if y is None else self
-    ._set_argument(x,y)
-      File ".\ifc_wrapper.py", line 114, in _set_argument
-        def _set_argument(self, *args): return _ifc_wrapper.entity_instance__set_argument(self, *args)
-    RuntimeError: INT is not a valid type for 'GlobalId'
-    >>> # Creating new entity instances
-    >>> f.createIfcCartesianPoint(Coordinates=(1.0,1.5,2.0))
-    #27530=IfcCartesianPoint((1.,1.5,2.))
-    >>> 
-    >>> # Working with GlobalId attributes:
-    >>> import uuid
-    >>> ifcopenshell.guid.compress(uuid.uuid1().hex)
-    '3x4C8Q_6qHuv$P$FYkANRX'
-    >>> new_guid = _
-    >>> owner_hist = f.by_type("IfcOwnerHistory")[0]
-    >>> new_wall = f.createIfcWallStandardCase(new_guid, owner_hist, None, None, Tag='my_tag')
-    >>> new_wall.ObjectType = ''
-    >>> new_wall.ObjectPlacement = new_wall.Representation = None
-    >>>
-    >>> # Accessing entity instances by instance id or GlobalId:
-    >>> f[92]
-    #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')
-    >>> f['2O2Fr$t4X7Zf8NOew3FLIE']
-    #92=IfcWallStandardCase('2O2Fr$t4X7Zf8NOew3FLIE',#1,'Basic Wall:Interior - Partition (92mm Stud):143921',$,'Basic Wall:Interior - Partition (92mm Stud):128360',#5206,#18805,'143921')
-    >>>
-    >>> # Writing IFC-SPF files to disk:
-    >>> f.write("out.ifc")
-
-[LGPL]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/COPYING "LGPL"
+[LGPL]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/COPYING.LESSER "LGPL-3.0-or-later"
 [IFC]: https://technical.buildingsmart.org/standards/ifc/ "IFC"
 [IFC2x3 TC1]: https://standards.buildingsmart.org/IFC/RELEASE/IFC2x3/TC1/HTML/ "IFC2x3 TC1"
 [IFC4 Add2 TC1]: https://standards.buildingsmart.org/IFC/RELEASE/IFC4/ADD2_TC1/HTML/ "IFC4 Add2 TC1"
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Do not remove this test for UTF-8: if “Ω” doesn’t appear as greek uppercase omega letter enclosed in quotation marks, you should use an editor that supports UTF-8, not this one. -->
+<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
+  <metadata>
+    <id>blenderbim-nightly</id>
+    <version>blenderbim_build_version-alpha</version>
+    <packageSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</packageSourceUrl>
+    <owners>fbpyr</owners>
+    <!-- == SOFTWARE SPECIFIC SECTION == -->
+    <title>BlenderBIM install nightly</title>
+    <authors>Dion Moult and many more, see: https://github.com/IfcOpenShell/IfcOpenShell/graphs/contributors</authors>
+    <projectUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectUrl>
+    <iconUrl>https://rawcdn.githack.com/IfcOpenShell/IfcOpenShell/c6ee1d1679d1298de0d7447ff108c22709c68e54/choco/blenderbim/blenderbim.png</iconUrl>
+    <!-- <copyright>Year Software Vendor</copyright> -->
+    <licenseUrl>https://github.com/IfcOpenShell/IfcOpenShell/blob/v0.7.0/COPYING</licenseUrl>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <projectSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectSourceUrl>
+    <docsUrl>https://blenderbim.org/docs/</docsUrl>
+    <!--<mailingListUrl></mailingListUrl>-->
+    <bugTrackerUrl>https://github.com/IfcOpenShell/IfcOpenShell/issues</bugTrackerUrl>
+    <tags>blender bim blenderbim ifc python opensource foss</tags>
+    <summary>opensource bim</summary>
+    <description>opensource bim addon for blender - source code at: https://github.com/IfcOpenShell/IfcOpenShell</description>
+    <!-- <releaseNotes>__REPLACE_OR_REMOVE__MarkDown_Okay</releaseNotes> -->
+
+    <dependencies>
+      <dependency id="blender" version="latest_blender_version_maj_min_pat" />
+      <dependency id="7zip"    version="22.1"/>
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="tools\**" target="tools" />
+  </files>
+</package>
@@ -0,0 +1,80 @@
+import datetime
+import re
+import sys
+from urllib import request
+
+
+def request_repo_info(url: str):
+    req  = request.Request(url)
+    resp = request.urlopen(req)
+    if not resp.status == 200:
+        print(f"[ERROR] could not contact server: {url}")
+        quit(1)
+    return resp
+
+
+if sys.argv[1] == "--do_choco_release?":
+    now = datetime.datetime.now()
+    blenderbim_date = (now - datetime.timedelta(days=1)).strftime("%y%m%d")
+    url = "https://github.com/IfcOpenShell/IfcOpenShell/releases"
+    resp = request_repo_info(url)
+    text = str(resp.read())
+    if blenderbim_date in text:
+        print("do_choco_release", end="")
+
+
+elif sys.argv[1] == "--latest_blender_release_maj_min_pat?":
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        print(found[0], end="")
+
+
+elif sys.argv[1] == "--latest_blender_release_maj_min?":
+    re_blender_version_min_maj = r"Latest Version.+<span>Blender (\d+\.\d+)\..+</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj, html_txt)
+    if found:
+        print(found[0], end="")
+
+
+elif sys.argv[1] == "--latest_blender_python_version_maj_min?":
+    # get latest blender version first
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        latest_blender_version_tag = f"v{found[0]}"
+        re_blender_python_version_maj_min = r"SET\(PYTHON_VERSION (\d+.\d+) "
+        url = f"https://raw.githubusercontent.com/blender/blender/{latest_blender_version_tag}/build_files/cmake/Modules/FindPythonLibsUnix.cmake"
+        resp = request_repo_info(url)
+        html_txt = str(resp.read())
+        found = re.findall(re_blender_python_version_maj_min, html_txt)
+        if found:
+            print(found[0], end="")
+
+
+elif sys.argv[1] == "--pyver?":
+    # get latest blender version first
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        latest_blender_version_tag = f"v{found[0]}"
+        re_blender_python_version_maj_min = r"SET\(PYTHON_VERSION (\d+.\d+) "
+        url = f"https://raw.githubusercontent.com/blender/blender/{latest_blender_version_tag}/build_files/cmake/Modules/FindPythonLibsUnix.cmake"
+        resp = request_repo_info(url)
+        html_txt = str(resp.read())
+        found = re.findall(re_blender_python_version_maj_min, html_txt)
+        if found:
+            print(f"py{found[0].replace('.', '')}", end="")
+
@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+
+
+print("[INFO] inserting dynamic chocolatey package parameters")
+HERE_DIR = Path(__file__).parent.absolute()
+# print(f"[INFO] HERE_DIR: {HERE_DIR}")
+
+topics = {
+    "spec": {
+        "path": HERE_DIR / "blenderbim.nuspec",
+        "env_vars": {
+            "latest_blender_version_maj_min_pat",
+            "blenderbim_build_version",
+        },
+    },
+    "install": {
+        "path": HERE_DIR / "tools" / "chocolateyinstall.ps1",
+        "env_vars": {
+            "url_blenderbim_py310_win_zip",
+            "sha256sum_blenderbim_py310_win_zip",
+            "latest_blender_version_maj_min",
+        },
+    },
+    "uninstall": {
+        "path": HERE_DIR / "tools" / "chocolateyuninstall.ps1",
+        "env_vars": {
+            "latest_blender_version_maj_min",
+        },
+    },
+}
+
+for topic, info in topics.items():
+    print(f"[INFO] {topic}:")
+    for env_var_name in info["env_vars"]:
+        print(f"[INFO] {env_var_name} exists?: {os.environ[env_var_name]}")
+
+    with open(info["path"], encoding="utf-8") as txt:
+        content = txt.read()
+
+    for env_var_name in info["env_vars"]:
+        # print(f"[INFO] replace: {env_var_name}")
+        content = content.replace(env_var_name, os.environ[env_var_name])
+
+    with open(info["path"], "w", encoding="utf-8") as txt:
+        txt.write(content)
+        print(f"[INFO] written: {info['path']}")
+
+print("[INFO] inserting dynamic chocolatey package parameters successful")
@@ -0,0 +1,11 @@
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+if($blenderIsRunning -eq $null) {
+    echo "Blender is not running ready for next action."
+}
+else {
+    Write-Warning "$processName is still running - installer cannot safely proceed to next action."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}
@@ -0,0 +1,29 @@
+$ErrorActionPreference = 'Stop'
+
+$url64          = 'url_blenderbim_py310_win_zip'
+$checksum64     = 'sha256sum_blenderbim_py310_win_zip'
+$checksumType64 = 'sha256'
+
+$appDataUserDir  = [System.Environment]::GetEnvironmentVariable('appdata')
+$unzipTargetDir  = "$appDataUserDir\Blender Foundation\Blender\latest_blender_version_maj_min\scripts\addons"
+
+$chocoBaseDir    = [System.Environment]::GetEnvironmentVariable('ChocolateyInstall')
+$addonEnable     = "$chocoBaseDir\lib\blenderbim-nightly\tools\enable_blenderbim_addon.py"
+
+$programFilesDir = [System.Environment]::GetEnvironmentVariable('ProgramFiles')
+$blenderExePath  = "$env:ProgramFiles\Blender Foundation\Blender latest_blender_version_maj_min\blender.exe"
+
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+
+if($blenderIsRunning -eq $null) {
+    echo "attempting to install blenderbim."
+    Install-ChocolateyZipPackage -PackageName $env:ChocolateyPackageName -Url64 $url64 -Checksum64 $checksum64 -checksumType $checksumType64 -UnzipLocation $unzipTargetDir
+    Start-Process -FilePath  $blenderExePath -ArgumentList "-b", "-y", "--python", "$addonEnable"
+}
+else {
+    Write-Warning "$processName is still running - blenderbim cannot be safely installed."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}
@@ -0,0 +1,22 @@
+$appDataUserDir = [System.Environment]::GetEnvironmentVariable('appdata')
+$unzippedDir = "$appDataUserDir\Blender Foundation\Blender\latest_blender_version_maj_min\scripts\addons\blenderbim"
+
+$chocoBaseDir    = [System.Environment]::GetEnvironmentVariable('ChocolateyInstall')
+$addonDisable     = "$chocoBaseDir\lib\blenderbim-nightly\tools\disable_blenderbim_addon.py"
+
+$programFilesDir = [System.Environment]::GetEnvironmentVariable('ProgramFiles')
+$blenderExePath  = "$env:ProgramFiles\Blender Foundation\Blender latest_blender_version_maj_min\blender.exe"
+
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+if($blenderIsRunning -eq $null) {
+    echo "attempting to uninstall blenderbim."
+    Start-Process -FilePath $blenderExePath -ArgumentList "-b", "-y", "--python", "$addonDisable"
+    Remove-Item -LiteralPath $unzippedDir -Force -Recurse
+}
+else {
+    Write-Warning "$processName is still running - blenderbim cannot be safely uninstalled."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}
@@ -0,0 +1,8 @@
+import bpy
+
+
+bpy.ops.preferences.addon_disable(module='blenderbim')
+bpy.ops.wm.save_userpref()
+
+print("disabled blenderbim addon successfully.")
+
@@ -0,0 +1,8 @@
+import bpy
+
+
+bpy.ops.preferences.addon_enable(module='blenderbim')
+bpy.ops.wm.save_userpref()
+
+print("enabled blenderbim addon successfully.")
+
@@ -18,10 +18,15 @@
 ################################################################################

 cmake_minimum_required(VERSION 3.1.3)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)  # not necessary, but encouraged

-project (IfcOpenShell VERSION 0.6.0)
+project (IfcOpenShell VERSION 0.7.0)
+
+cmake_policy(SET CMP0048 NEW)
+cmake_policy(SET CMP0074 NEW)
+cmake_policy(SET CMP0078 OLD)
+cmake_policy(SET CMP0086 NEW)

 # use extra version to make pre-release using eg semver
 set( EXTRA_VERSION "-alpha.3")
@@ -33,11 +38,10 @@ MESSAGE(STATUS "Autodesk 3ds Max SDK found at ${max_sdk}")
 set(HAS_MAX TRUE)
 endif()
 endforeach()
-
+OPTION(MINIMAL_BUILD "The build is to make a minimal version of IFC converter from OCCT into IFC." OFF)
 OPTION(COLLADA_SUPPORT "Build IfcConvert with COLLADA support (requires OpenCOLLADA)." ON)
 OPTION(IFCXML_SUPPORT "Build IfcParse with ifcXML support (requires libxml2)." ON)
 OPTION(ENABLE_BUILD_OPTIMIZATIONS "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds." OFF)
-OPTION(IFCCONVERT_DOUBLE_PRECISION "IfcConvert: Use double precision floating-point numbers." ON)
 OPTION(BUILD_PACKAGE "" OFF)
 OPTION(BUILD_IFCGEOM "Build IfcGeom." ON)
 OPTION(BUILD_DOCUMENTATION "Build IfcOpenShell Documentation." OFF)
@@ -45,19 +49,31 @@ OPTION(BUILD_IFCPYTHON "Build IfcPython." ON)
 OPTION(BUILD_EXAMPLES "Build example applications." ON)
 OPTION(BUILD_GEOMSERVER "Build IfcGeomServer executable." ON)
 OPTION(BUILD_CONVERT "Build IfcConvert executable." ON)
+OPTION(HDF5_SUPPORT "Enable HDF5 support (requires HDF5, zlib)" ON)
 OPTION(USE_VLD "Use Visual Leak Detector for debugging memory leaks, MSVC-only." OFF)
 OPTION(USE_MMAP "Adds a command line options to parse IFC files from memory mapped files using Boost.Iostreams" OFF)
 OPTION(BUILD_SHARED_LIBS "Build IfcParse and IfcGeom as shared libs (SO/DLL)." OFF)
+OPTION(MSVC_PARALLEL_BUILD "Multi-threaded compilation in Microsoft Visual Studio (/MP)" OFF)
+OPTION(WASM_BUILD OFF)
 if (${HAS_MAX})
-OPTION(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." ON)
+OPTION(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." OFF)
 endif()
 if (${BUILD_CONVERT})
 OPTION(GLTF_SUPPORT "Build IfcConvert with glTF support (requires json.hpp)." OFF)
 endif()
 OPTION(USERSPACE_PYTHON_PREFIX "Installs IfcPython for the current user only instead of system-wide." OFF)
+OPTION(ADD_COMMIT_SHA "Add commit sha and branch in version number, warning results in many rebuilds, requires git" OFF)

-# TODO QtViewer is deprecated ATM as it uses the 0.4 API
-# OPTION(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer (requires Qt 4 framework)." OFF)
+IF(NOT CMAKE_BUILD_TYPE)
+	SET(CMAKE_BUILD_TYPE "Release")
+ENDIF()
+
+if(MSVC AND MSVC_PARALLEL_BUILD)
+	add_definitions("/MP")
+endif()
+
+# QtViewer requires Qt5
+OPTION(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer" OFF)
 include(GNUInstallDirs)
 if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND (NOT BUILD_IFCGEOM))
    message(STATUS "'IfcGeom' is required with current outputs")
@@ -111,14 +127,38 @@ ENDMACRO()

 UNIFY_ENVVARS_AND_CACHE(OCC_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(OCC_LIBRARY_DIR)
+if (NOT MINIMAL_BUILD)
 UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(LIBXML2_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(LIBXML2_LIBRARIES)
 UNIFY_ENVVARS_AND_CACHE(PCRE_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(PYTHON_EXECUTABLE)
+UNIFY_ENVVARS_AND_CACHE(HDF5_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARIES)
+endif()
+UNIFY_ENVVARS_AND_CACHE(BOOST_ROOT)
+UNIFY_ENVVARS_AND_CACHE(BOOST_LIBRARYDIR)

-if (GLTF_SUPPORT AND BUILD_CONVERT)
+if (NOT MINIMAL_BUILD)
+UNIFY_ENVVARS_AND_CACHE(CGAL_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(CGAL_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(GMP_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(GMP_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(MPFR_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(MPFR_LIBRARY_DIR)
+endif()
+
+if(WASM_BUILD)
+    # when using the nix/build-all.py build script we should not
+    # look into the sysroot for most of the dependencies but rather
+    # in the designated build/ folder created by the script.
+    set(CMAKE_FIND_ROOT_PATH_BACKUP "${CMAKE_FIND_ROOT_PATH}")
+    set(CMAKE_FIND_ROOT_PATH "")
+endif()
+
+if (NOT MINIMAL_BUILD AND GLTF_SUPPORT AND BUILD_CONVERT)
 UNIFY_ENVVARS_AND_CACHE(JSON_INCLUDE_DIR)
 FIND_FILE(json_hpp "json.hpp" ${JSON_INCLUDE_DIR}/nlohmann)
 IF(json_hpp)
@@ -127,6 +167,7 @@ ELSE()
 	MESSAGE(FATAL_ERROR "Unable to find JSON for Modern C++ header file, aborting")
 ENDIF()
 add_definitions(-DWITH_GLTF)
+set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_GLTF)
 endif()

 # Set INSTALL_RPATH for target
@@ -146,7 +187,7 @@ ENDMACRO()
 # runtime, when doing running conda-build we pick what conda prepared for us.
 IF(WIN32 AND ("$ENV{CONDA_BUILD}" STREQUAL ""))
 	SET(Boost_USE_STATIC_LIBS ON)
-	SET(Boost_USE_STATIC_RUNTIME ON)
+	SET(Boost_USE_STATIC_RUNTIME OFF)
 	SET(Boost_USE_MULTITHREADED ON)
    # Disable Boost's autolinking as the libraries to be linked to are supplied
    # already by CMake, and wrong libraries would be asked for when code is
@@ -167,7 +208,14 @@ ELSE()
    ENDIF()
 ENDIF()

-set(BOOST_COMPONENTS system program_options regex thread date_time)
+if (WASM_BUILD)
+    set(BOOST_COMPONENTS)
+else()
+    # @todo review this, shouldn't this be all possible header-only now?
+    # ... or rewritten using C++17 features?
+    set(BOOST_COMPONENTS system program_options regex thread date_time)
+endif()
+
 if(USE_MMAP)
    if(MSVC)
        # filesystem is necessary for the utf-16 wpath
@@ -178,15 +226,20 @@ if(USE_MMAP)
    add_definitions(-DUSE_MMAP)
 endif()

-if (IFCXML_SUPPORT)
-    find_package(LibXml2 REQUIRED)
-    add_definitions(-DWITH_IFCXML)
-endif()
-
 FIND_PACKAGE(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
 MESSAGE(STATUS "Boost include files found in ${Boost_INCLUDE_DIRS}")
 MESSAGE(STATUS "Boost libraries found in ${Boost_LIBRARY_DIRS}")

+if (NOT MINIMAL_BUILD)
+# libxml2 is required for IFCXML (optional) and SVGFILL (mandatory)
+  find_package(LibXml2 REQUIRED)
+endif()
+
+if (NOT MINIMAL_BUILD AND IFCXML_SUPPORT)
+    add_definitions(-DWITH_IFCXML)
+	set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_IFCXML)
+endif()
+
 # Usage:
 # set(SOME_LIRARIES foo bar)
 # add_debug_variants(SOME_LIRARIES "${SOME_LIRARIES}" d)
@@ -250,6 +303,9 @@ ENDIF()
 SET(OPENCASCADE_LIBRARY_NAMES
    TKernel TKMath TKBRep TKGeomBase TKGeomAlgo TKG3d TKG2d TKShHealing TKTopAlgo TKMesh TKPrim TKBool TKBO
    TKFillet TKSTEP TKSTEPBase TKSTEPAttr TKXSBase TKSTEP209 TKIGES TKOffset TKHLR
+    
+    # @todo investigate the exact conditions when this is necessary
+    TKBin
 )

 IF("${OCC_LIBRARY_DIR}" STREQUAL "")
@@ -302,10 +358,21 @@ if("${libTKernelExt}" STREQUAL ".a")
    set(OCCT_STATIC ON)
 endif()

+if(WASM_BUILD)
+    set(CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH_BACKUP}")
+endif()
+
 if(OCCT_STATIC)
    find_package(Threads)
-    # OPENCASCADE_LIBRARIES repeated three times below in order to fix cyclic dependencies - use --start-group ... --end-group instead?
-    set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    
+    if(WASM_BUILD)
+        set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    else()
+        # OPENCASCADE_LIBRARIES repeated N times below in order to fix cyclic dependencies - use --start-group ... --end-group instead?
+        # tfk: --start-group ... --end-group didn't work on the apple linker when last tested
+        set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    endif()
+    
    if (NOT APPLE AND NOT WIN32)
        set(OPENCASCADE_LIBRARIES ${OPENCASCADE_LIBRARIES} "rt")
    endif()
@@ -316,7 +383,7 @@ endif()

 endif(BUILD_IFCGEOM)

-IF(COLLADA_SUPPORT AND BUILD_CONVERT)
+IF(NOT MINIMAL_BUILD AND COLLADA_SUPPORT)
 	# Find OpenCOLLADA
 	IF("${OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
 		MESSAGE(STATUS "No OpenCOLLADA include directory specified")
@@ -348,6 +415,8 @@ IF(COLLADA_SUPPORT AND BUILD_CONVERT)
 	IF(COLLADASWStreamWriter_h)
 		MESSAGE(STATUS "OpenCOLLADA header files found")
 		ADD_DEFINITIONS(-DWITH_OPENCOLLADA)
+		set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_OPENCOLLADA)
+
 		SET(OPENCOLLADA_LIBRARY_NAMES
 			GeneratedSaxParser MathMLSolver OpenCOLLADABaseUtils OpenCOLLADAFramework OpenCOLLADASaxFrameworkLoader
 			OpenCOLLADAStreamWriter UTF buffer ftoa
@@ -394,9 +463,87 @@ IF(COLLADA_SUPPORT AND BUILD_CONVERT)
 	ENDIF()
 ENDIF()

-IF(NOT CMAKE_BUILD_TYPE)
-	SET(CMAKE_BUILD_TYPE "Release")
-ENDIF()
+if(NOT MINIMAL_BUILD AND HDF5_SUPPORT)
+    IF("${HDF5_INCLUDE_DIR}" STREQUAL "")
+		MESSAGE(STATUS "No HDF5 include directory specified")
+	ElSE()
+		SET(HDF5_INCLUDE_DIR "${HDF5_INCLUDE_DIR}" CACHE FILEPATH "HDF5 header files")
+	ENDIF()
+	
+    IF("${HDF5_LIBRARY_DIR}" STREQUAL "")
+		MESSAGE(STATUS "No HDF5 library directory specified")
+	ElSE()
+		SET(HDF5_LIBRARY_DIR "${HDF5_LIBRARY_DIR}" CACHE FILEPATH "HDF5 library files")
+	ENDIF()
+
+    if (HDF5_LIBRARY_DIR)
+    	# result of the HDF5 ctest package
+        # Find zlib using cmake find_library. How should this be implemented?
+        # FIND_LIBRARY(NAMES z libz libz_debug PATHS ... NO_DEFAULT_PATH)
+
+
+        if ("$ENV{CONDA_BUILD}" STREQUAL "")
+            # result of the HDF5 ctest package
+
+            if (WIN32)
+                set(zlib_post lib)
+                set(lib_ext lib)
+            else()
+                set(lib_ext a)
+            endif()
+
+            if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+                set(debug_postfix "_debug")
+            endif()
+
+            SET(HDF5_LIBRARIES
+                    "${HDF5_LIBRARY_DIR}/libhdf5_cpp${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libhdf5${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libz${zlib_post}${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libsz${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libaec${debug_postfix}.${lib_ext}"
+                    )
+
+        ELSE()
+            MESSAGE(STATUS "Packaging hdf5 and zlib for conda distribution")
+            if (WIN32)
+                # Windows
+                set(zlib_post zlib)
+                set(lib_ext lib)
+            elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+                # macOS
+                set(zlib_post libz)
+                set(lib_ext dylib)
+            else()
+                # linux
+                set(zlib_post libz)
+                set(lib_ext so)
+            endif()
+
+            SET(HDF5_LIBRARIES
+                    "${HDF5_LIBRARY_DIR}/libhdf5_cpp.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libhdf5.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/${zlib_post}.${lib_ext}"
+                    )
+        endif()
+
+    endif()
+
+    if (NOT HDF5_LIBRARIES)
+    	# debian default
+
+        SET(HDF5_LIBRARIES
+            /usr/lib/x86_64-linux-gnu/hdf5/serial/libhdf5_cpp.so
+            /usr/lib/x86_64-linux-gnu/hdf5/serial/libhdf5.so
+            /usr/lib/x86_64-linux-gnu/libsz.so
+            /usr/lib/x86_64-linux-gnu/libaec.so
+            z dl
+        )
+    endif()
+    
+    add_definitions(-DWITH_HDF5)
+	set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_HDF5)
+endif()

 if(ENABLE_BUILD_OPTIMIZATIONS)
 	if(MSVC)
@@ -422,6 +569,14 @@ if(ENABLE_BUILD_OPTIMIZATIONS)
 endif()

 IF(MSVC)
+	# warning due to virtual inheritance
+	ADD_DEFINITIONS(-wd4250)
+	# warning due to select definitions in the schema being redundant
+	ADD_DEFINITIONS(-wd4584)
+	
+	# didn't work well on ifcopenbot, @todo make configurable
+	# add_definitions(/MP)
+
    # Enable solution folders (free VS versions prior to 2012 don't support solution folders)
    if (MSVC_VERSION GREATER 1600)
        set_property(GLOBAL PROPERTY USE_FOLDERS ON)
@@ -447,18 +602,18 @@ IF(MSVC)
    endif()
 	# Link against the static VC runtime
    # TODO Make this configurable
-	IF("$ENV{CONDA_BUILD}" STREQUAL "")
-	FOREACH(flag CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL
-			CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
-			CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
-		IF(${flag} MATCHES "/MD")
-			STRING(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
-		ENDIF()
-		IF(${flag} MATCHES "/MDd")
-			STRING(REGEX REPLACE "/MDd" "/MTd" ${flag} "${${flag}}")
-		ENDIF()
-	ENDFOREACH()
-	ENDIF()
+	# IF("$ENV{CONDA_BUILD}" STREQUAL "")
+	# FOREACH(flag CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL
+			# CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+			# CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
+		# IF(${flag} MATCHES "/MD")
+			# STRING(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
+		# ENDIF()
+		# IF(${flag} MATCHES "/MDd")
+			# STRING(REGEX REPLACE "/MDd" "/MTd" ${flag} "${${flag}}")
+		# ENDIF()
+	# ENDFOREACH()
+	# ENDIF()
 ElSE()
    add_definitions(-Wall -Wextra)
    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
@@ -476,12 +631,8 @@ ElSE()
    endif()
 ENDIF()

-if (IFCCONVERT_DOUBLE_PRECISION)
-    SET(CONVERT_PRECISION "-DIFCCONVERT_DOUBLE_PRECISION")
-endif()
-
 INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${OCC_INCLUDE_DIR} ${OPENCOLLADA_INCLUDE_DIRS}
-	${Boost_INCLUDE_DIRS} ${LIBXML2_INCLUDE_DIR} ${JSON_INCLUDE_DIR}
+	${Boost_INCLUDE_DIRS} ${LIBXML2_INCLUDE_DIR} ${JSON_INCLUDE_DIR} ${HDF5_INCLUDE_DIR}
 )

 function(files_for_ifc_version IFC_VERSION RESULT_NAME)
@@ -495,13 +646,21 @@ function(files_for_ifc_version IFC_VERSION RESULT_NAME)
 endfunction()

 if(NOT SCHEMA_VERSIONS)
-    set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3_rc1" "4x3_rc2" "4x3_rc3" "4x3_rc4")
+    if(WASM_BUILD)
+        # super arbitrarily try to keep size down at least a little bit
+        set(SCHEMA_VERSIONS "2x3" "4")
+    else()
+        set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3_rc1" "4x3_rc2" "4x3_rc3" "4x3_rc4" "4x3" "4x3_tc1" "4x3_add1")
+    endif()
 endif()

 foreach(s ${SCHEMA_VERSIONS})
 	add_definitions(-DHAS_SCHEMA_${s})
 endforeach()

+string(REPLACE ";" ")(" schema_version_seq "(${SCHEMA_VERSIONS})")
+ADD_DEFINITIONS(-DSCHEMA_SEQ=${schema_version_seq})
+
 if(COMPILE_SCHEMA)
 	# @todo, this appears to be untested at the moment

@@ -569,9 +728,13 @@ if (BUILD_IFCGEOM)
 	foreach(s ${SCHEMA_VERSIONS})
 		set(IFCGEOM_SCHEMA_LIBRARIES ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom_ifc${s})
 	endforeach()
-	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})
+	if (WASM_BUILD)
+	    set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})
+	else()
+	    set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})	
+	endif()
 endif()
-if (BUILD_CONVERT)
+if (BUILD_CONVERT OR BUILD_IFCPYTHON)
 	foreach(s ${SCHEMA_VERSIONS})
 		set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} Serializers_ifc${s})
 	endforeach()
@@ -613,19 +776,25 @@ set(IFCPARSE_FILES ${IFCPARSE_CPP_FILES} ${IFCPARSE_H_FILES})
 add_library(IfcParse ${IFCPARSE_FILES})
 set_target_properties(IfcParse PROPERTIES COMPILE_FLAGS -DIFC_PARSE_EXPORTS VERSION "0.6.0" SOVERSION "0.6")

-TARGET_LINK_LIBRARIES(IfcParse ${Boost_LIBRARIES} ${BCRYPT_LIBRARIES} ${LIBXML2_LIBRARIES})
+if (WASM_BUILD)
+    TARGET_LINK_LIBRARIES(IfcParse ${BCRYPT_LIBRARIES} ${LIBXML2_LIBRARIES})
+else()
+    TARGET_LINK_LIBRARIES(IfcParse ${Boost_LIBRARIES} ${BCRYPT_LIBRARIES} ${LIBXML2_LIBRARIES})
+endif()

 if (BUILD_IFCGEOM)

 # IfcGeom
-file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/*.h)
+file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/*.h ../src/ifcgeom/*.i)
 file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/*.cpp)
 set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})

 foreach(s ${SCHEMA_VERSIONS})
 	add_library(IfcGeom_ifc${s} STATIC ${IFCGEOM_FILES})
 	set_target_properties(IfcGeom_ifc${s} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${s}")
-	TARGET_LINK_LIBRARIES(IfcGeom_ifc${s} IfcParse ${OPENCASCADE_LIBRARIES})
+	if (NOT WASM_BUILD)
+	    TARGET_LINK_LIBRARIES(IfcGeom_ifc${s} IfcParse ${OPENCASCADE_LIBRARIES})	    
+	endif()
 endforeach()

 # IfcGeom (schema agnostic)
@@ -640,11 +809,15 @@ if (UNIX)
 find_package(Threads)
 endif()

-TARGET_LINK_LIBRARIES(IfcGeom IfcParse ${IFCGEOM_SCHEMA_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+if (WASM_BUILD)
+    TARGET_LINK_LIBRARIES(IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+else()
+    TARGET_LINK_LIBRARIES(IfcGeom IfcParse ${IFCGEOM_SCHEMA_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+endif()

 endif(BUILD_IFCGEOM)

-if (BUILD_CONVERT)
+if (BUILD_CONVERT OR BUILD_IFCPYTHON)

 # Serializers
 file(GLOB SERIALIZERS_H_FILES ../src/serializers/*.h)
@@ -657,13 +830,22 @@ set(SERIALIZERS_S_FILES ${SERIALIZERS_S_H_FILES} ${SERIALIZERS_S_CPP_FILES})
 foreach(s ${SCHEMA_VERSIONS})
 	add_library(Serializers_ifc${s} STATIC ${SERIALIZERS_S_FILES})
 	set_target_properties(Serializers_ifc${s} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${s} ${CONVERT_PRECISION}")
-	TARGET_LINK_LIBRARIES(Serializers_ifc${s} IfcGeom ${OPENCASCADE_LIBRARIES})
+	
+	if (WASM_BUILD)
+	    TARGET_LINK_LIBRARIES(Serializers_ifc${s} ${HDF5_LIBRARIES})
+	else()
+	    TARGET_LINK_LIBRARIES(Serializers_ifc${s} IfcGeom ${OPENCASCADE_LIBRARIES} ${HDF5_LIBRARIES})
+	endif()
 endforeach()

 add_library(Serializers ${SERIALIZERS_FILES})
 set_target_properties(Serializers PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS ${CONVERT_PRECISION}" VERSION "0.6.0" SOVERSION "0.6")

-TARGET_LINK_LIBRARIES(Serializers ${SERIALIZER_SCHEMA_LIBRARIES})
+TARGET_LINK_LIBRARIES(Serializers ${SERIALIZER_SCHEMA_LIBRARIES} ${OPENCOLLADA_LIBRARIES})
+
+endif(BUILD_CONVERT or BUILD_IFCPYTHON)
+
+if (BUILD_CONVERT)

 # IfcConvert
 file(GLOB IFCCONVERT_CPP_FILES ../src/ifcconvert/*.cpp)
@@ -672,7 +854,7 @@ set(IFCCONVERT_FILES ${IFCCONVERT_CPP_FILES} ${IFCCONVERT_H_FILES})
 ADD_EXECUTABLE(IfcConvert ${IFCCONVERT_FILES})
 set_target_properties(IfcConvert PROPERTIES COMPILE_FLAGS "${CONVERT_PRECISION}")

-TARGET_LINK_LIBRARIES(IfcConvert ${IFCOPENSHELL_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${Boost_LIBRARIES} ${OPENCOLLADA_LIBRARIES})
+TARGET_LINK_LIBRARIES(IfcConvert ${IFCOPENSHELL_LIBRARIES} ${OPENCASCADE_LIBRARIES} ${Boost_LIBRARIES} ${HDF5_LIBRARIES})

 if ((NOT WIN32) AND BUILD_SHARED_LIBS)
    # Only set RPATHs when building shared libraries (i.e. IfcParse and
@@ -690,7 +872,7 @@ INSTALL(TARGETS IfcConvert
 endif(BUILD_CONVERT)

 # IfcGeomServer
-if(BUILD_GEOMSERVER)
+if(NOT MINIMAL_BUILD AND BUILD_GEOMSERVER)

 file(GLOB CPP_FILES ../src/ifcgeomserver/*.cpp)
 file(GLOB H_FILES ../src/ifcgeomserver/*.h)
@@ -710,13 +892,42 @@ INSTALL(TARGETS IfcGeomServer

 endif()

+if (ADD_COMMIT_SHA)
+find_package (Git)
+if (GIT_FOUND)
+	message("git found: ${GIT_EXECUTABLE} with version ${GIT_VERSION_STRING}")
+	execute_process(
+		COMMAND ${GIT_EXECUTABLE} branch --contains HEAD
+		OUTPUT_VARIABLE git_branches
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+	)
+	string(REPLACE "\n" ";" git_branch_list "${git_branches}")
+	foreach(git_branch_candidate IN ITEMS ${git_branch_list})
+		string(REPLACE "*" "" git_branch_candidate_temp "${git_branch_candidate}")
+		string(STRIP "${git_branch_candidate_temp}" git_branch_candidate_2)
+		if (NOT git_branch_candidate_2 MATCHES "^HEAD$")
+			set(git_branch ${git_branch_candidate_2})
+		endif()
+	endforeach()
+	execute_process(
+		COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
+		OUTPUT_VARIABLE git_sha
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+	)
+	message(STATUS "IfcOpenShell branch: \"${git_branch}\"")
+	message(STATUS "IfcOpenShell commit: \"${git_sha}\"")
+	add_definitions(-DIFCOPENSHELL_BRANCH=${git_branch})
+	add_definitions(-DIFCOPENSHELL_COMMIT=${git_sha})
+endif()
+endif()
+
 # Documentation
 IF(BUILD_DOCUMENTATION)
 	set(CMAKE_MODULE_PATH "../docs/cmake")
 	ADD_SUBDIRECTORY(../docs docs)
 ENDIF()

-IF(BUILD_IFCPYTHON)
+IF(NOT MINIMAL_BUILD AND BUILD_IFCPYTHON)
 	ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
 ENDIF()

@@ -724,9 +935,12 @@ IF(BUILD_EXAMPLES)
 	ADD_SUBDIRECTORY(../src/examples examples)
 ENDIF()

-IF(BUILD_IFCMAX)
+IF(NOT MINIMAL_BUILD AND BUILD_IFCMAX)
 	ADD_SUBDIRECTORY(../src/ifcmax ifcmax)
 ENDIF()
+if (NOT MINIMAL_BUILD)
+ADD_SUBDIRECTORY(../src/svgfill svgfill)
+endif()

 # CMake installation targets
 INSTALL(FILES ${IFCPARSE_H_FILES}
@@ -771,6 +985,9 @@ INSTALL(FILES  ${SERIALIZERS_S_FILES}
 )
 endif()

+IF(BUILD_QTVIEWER)
+    ADD_SUBDIRECTORY(../src/qtviewer qtviewer)
+endif()

 list(APPEND CPACK_SOURCE_IGNORE_FILES
  .git
@@ -795,12 +1012,12 @@ set(CPACK_SOURCE_GENERATOR "TGZ")

 FOREACH(COMPONENT IN ITEMS ${BOOST_COMPONENTS})
    string(REPLACE "_" "-" COMP ${COMPONENT})
-    set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}1.67.0")
+    set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}-dev")
 endforeach(COMPONENT)

 set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_CONTACT}")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, liboce-foundation11, liboce-modeling11, liboce-ocaf11, liboce-visualization11, liboce-ocaf-lite11, libpython3.8 ${BOOST_DEPS}")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, libocct-foundation-dev, libocct-modeling-algorithms-dev, libocct-modeling-data-dev, libocct-ocaf-dev, libocct-visualization-dev, libocct-data-exchange-dev, libhdf5-serial-dev, libpython3.8 ${BOOST_DEPS}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION_SUMMARY "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
@@ -0,0 +1,8 @@
+compile:
+	conda activate conda-build && conda-build -c conda-forge . --keep-old-work --python 3.10.5
+
+debug:
+	conda activate conda-build && conda-debug -c conda-forge . --python 3.10.4
+
+env:
+	conda env update --f environment.yml --prune
@@ -1,29 +1,44 @@
 mkdir build && cd build

-REM Remove dot from PY_VER for use in library name
-REM From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/bld.bat
 set MY_PY_VER=%PY_VER:.=%
+set LIBXML2="%LIBRARY_PREFIX%/lib/libxml2.lib"

-cmake -G "NMake Makefiles" ^
- -DCMAKE_INSTALL_PREFIX="%LIBRARY_PREFIX%" ^
- -DCMAKE_BUILD_TYPE=Release ^
- -DCMAKE_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DCMAKE_SYSTEM_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DPYTHON_EXECUTABLE="%PYTHON%" ^
- -DPYTHON_INCLUDE_DIR="%PREFIX%"/include ^
- -DPYTHON_LIBRARY="%PREFIX%"/libs/python%MY_PY_VER%.lib ^
- -DBOOST_LIBRARYDIR="%LIBRARY_PREFIX%\lib" ^
- -DBOOST_INCLUDEDIR="%LIBRARY_PREFIX%\include" ^
- -DOCC_INCLUDE_DIR="%LIBRARY_PREFIX%\include\oce" ^
- -DOCC_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
- -DCOLLADA_SUPPORT=Off ^
- -DBUILD_EXAMPLES=Off ^
- -DBUILD_GEOMSERVER=Off ^
- -DBUILD_CONVERT=Off ^
- ../cmake
- 
-if errorlevel 1 exit 1
-
-cmake --build . --target INSTALL --config Release
+cmake -G "Ninja" ^
+ -D CMAKE_BUILD_TYPE:STRING=Release ^
+ -D CMAKE_INSTALL_PREFIX:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D CMAKE_PREFIX_PATH:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D CMAKE_SYSTEM_PREFIX_PATH:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D OCC_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include\opencascade" ^
+ -D OCC_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D CGAL_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D GMP_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D GMP_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D MPFR_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D COLLADA_SUPPORT=OFF ^
+ -D HDF5_SUPPORT=ON ^
+ -D HDF5_INCLUDE_DIR="%LIBRARY_PREFIX%\include" ^
+ -D HDF5_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
+ -D JSON_INCLUDE_DIR="%LIBRARY_PREFIX%\include" ^
+ -D PYTHON_INCLUDE_DIR=%PREFIX%\include ^
+ -D PYTHON_EXECUTABLE:FILEPATH=%PREFIX%\python.exe ^
+ -D PYTHON_LIBRARY:FILEPATH="%PREFIX%"\libs/python%MY_PY_VER%.lib ^
+ -D BUILD_IFCPYTHON=ON ^
+ -D BUILD_IFCGEOM=ON ^
+ -D COLLADA_SUPPORT:BOOL=OFF ^
+ -D BUILD_EXAMPLES:BOOL=OFF ^
+ -D BUILD_GEOMSERVER:BOOL=OFF ^
+ -D GLTF_SUPPORT:BOOL=ON ^
+ -D BUILD_CONVERT:BOOL=ON ^
+ -D BUILD_IFCMAX:BOOL=OFF ^
+ -D IFCXML_SUPPORT:BOOL=ON ^
+ -D Boost_LIBRARYDIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D Boost_INCLUDEDIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D Boost_USE_STATIC_LIBS:BOOL=OFF ^
+ %SRC_DIR%/cmake
+
+if errorlevel 1 exit 1
+
+:: Build and install
+cmake --build . -- install

 if errorlevel 1 exit 1
@@ -1,34 +1,44 @@
-# From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/build.sh
-if [ "$PY3K" == "1" ]; then
-    MY_PY_VER="${PY_VER}m"
-else
-    MY_PY_VER="${PY_VER}"
+#!/bin/bash
+
+declare -a CMAKE_PLATFORM_FLAGS
+
+if [[ ${HOST} =~ .*linux.* ]]; then
+    CMAKE_PLATFORM_FLAGS+=(-DCMAKE_TOOLCHAIN_FILE=$RECIPE_DIR/cross-linux.cmake)
 fi

 if [ `uname` == Darwin ]; then
-    PY_LIB="libpython${MY_PY_VER}.dylib"
-    export   CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
-    export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
-    export  LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
-else
-    PY_LIB="libpython${MY_PY_VER}.so"
+  export CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
+  export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
+  export LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
 fi

-mkdir build && cd build
-
-cmake \
- -DCMAKE_INSTALL_PREFIX=$PREFIX \
+cmake -G Ninja \
 -DCMAKE_BUILD_TYPE=Release \
+ -DCMAKE_INSTALL_PREFIX=$PREFIX \
+  ${CMAKE_PLATFORM_FLAGS[@]} \
 -DCMAKE_PREFIX_PATH=$PREFIX \
 -DCMAKE_SYSTEM_PREFIX_PATH=$PREFIX \
- -DOCC_INCLUDE_DIR=$PREFIX/include/oce \
- -DOCC_LIBRARY_DIR=$PREFIX/lib \
 -DPYTHON_EXECUTABLE:FILEPATH=$PYTHON \
- -DPYTHON_INCLUDE_DIR:PATH=$PREFIX/include/python$MY_PY_VER \
- -DPYTHON_LIBRARY:FILEPATH=$PREFIX/lib/${PY_LIB} \
- -DCOLLADA_SUPPORT=Off \
- ../cmake
+ -DGMP_LIBRARY_DIR=$PREFIX/lib \
+ -DMPFR_LIBRARY_DIR=$PREFIX/lib \
+ -DOCC_INCLUDE_DIR=$PREFIX/include/opencascade \
+ -DOCC_LIBRARY_DIR=$PREFIX/lib \
+ -DHDF5_SUPPORT:BOOL=ON \
+ -DHDF5_INCLUDE_DIR=$PREFIX/include \
+ -DHDF5_LIBRARY_DIR=$PREFIX/lib \
+ -DJSON_INCLUDE_DIR=$PREFIX/include \
+ -DCGAL_INCLUDE_DIR=$PREFIX/include \
+ -DCOLLADA_SUPPORT=0 \
+ -DBUILD_EXAMPLES:BOOL=OFF \
+ -DIFCXML_SUPPORT:BOOL=ON \
+ -DGLTF_SUPPORT:BOOL=ON \
+ -DBUILD_CONVERT:BOOL=ON \
+ -DBUILD_IFCPYTHON:BOOL=ON \
+ -DBUILD_IFCGEOM:BOOL=ON \
+ -DBUILD_GEOMSERVER:BOOL=OFF \
+ -DBOOST_USE_STATIC_LIBS:BOOL=OFF \
+ ./cmake

-make -j$CPU_COUNT _ifcopenshell_wrapper
-cd ifcwrap
-make install/local
+ninja
+
+ninja install
@@ -0,0 +1,2 @@
+CONDA_BUILD_SYSROOT:
+  - /opt/MacOSX10.13.sdk       # [osx]
@@ -0,0 +1,16 @@
+# this one is important
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_PLATFORM Linux)
+
+# specify the cross compiler
+set(CMAKE_C_COMPILER $ENV{CC})
+set(CMAKE_CXX_COMPILER $ENV{CXX})
+
+# where is the target environment
+set(CMAKE_FIND_ROOT_PATH $ENV{PREFIX} $ENV{BUILD_PREFIX}/$ENV{HOST}/sysroot)
+
+# search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
@@ -0,0 +1,14 @@
+name: conda-build
+channels:
+  - conda-forge
+dependencies:
+  - conda-build
+  - conda-verify
+  - anaconda-client
+  - ninja
+  - doxygen
+  - ripgrep
+  - pip
+  - pip:
+      - --extra-index-url https://lief.s3-website.fr-par.scw.cloud/latest
+      - lief==0.13.0.dev0
@@ -1,36 +1,63 @@
+{% set name = "ifcopenshell" %}
+{% set version = "0.7.0" %}
+{% set occt_version = "7.6.2" %}
+{% set cgal_cpp_version = "5.3" %}
+{% set hdf5_version = "1.12.1" %}
+
 package:
-  name: ifcopenshell
-  version: "0.6.0a1"
+  name: {{ name }}
+  version: {{ version }}

 source:
-  git_rev: "v0.6.0a1"
-  git_url: https://github.com/IfcOpenShell/IfcOpenShell
+  path: ..

 build:
-  number: 0
-  features:
-    - vc9     # [win and py27]
-    - vc10    # [win and py34]
-    - vc14    # [win and py35]
-    - vc14    # [win and py36]
+  binary_relocation: false [osx]
+  number: 1

 requirements:
  build:
-    - gcc     # [osx]
-    - make
-    - python
-    - oce ==0.18.3
+    - {{ compiler('c') }}
+    - {{ compiler('cxx') }}
+    - ninja >=1.10.2
    - cmake
-    - swig >=3.0.9
-    - libboost
-    - icu
-  run:
-    - libgcc  # [osx]
+    - swig >=4.0.2
+
+  host:
    - python
-    - oce ==0.18.3
-    - libboost
-    - icu
+    - boost-cpp
+    - occt
+    - libxml2
+    - cgal-cpp
+    - hdf5
+    - mpfr
+    - gmp  # [unix]
+    - mpir  # [win]
+    - nlohmann_json
+
+  run:
+    - python
+    - boost-cpp
+    - occt
+    - libxml2
+    - cgal-cpp
+    - hdf5
+    - mpfr
+    - gmp  # [unix]
+    - mpir  # [win]
+    - nlohmann_json
+
+test:
+  imports:
+    - ifcopenshell

 about:
  home: http://ifcopenshell.org
-  license: LGPL
+  license: LGPL-3.0-or-later
+  license_file: COPYING
+  summary: 'IfcOpenShell is a library to support the IFC file format'
+  description: |
+    IfcOpenShell is an open source (LGPL) software library for 
+    working with the Industry Foundation Classes (IFC) file format.
+  doc_url: http://ifcopenshell.org/
+  dev_url: https://github.com/IfcOpenShell/IfcOpenShell
@@ -0,0 +1,20 @@
+--- a/tools/build/src/tools/emscripten.jam
+++ b/tools/build/src/tools/emscripten.jam
+@@ -6,6 +6,7 @@
+ import feature ;
+ import os ;
+ import toolset ;
+import generators ;
+ import common ;
+ import gcc ;
+ import type ;
+@@ -52,6 +53,8 @@
+         <debug-symbols>off <debug-symbols>on
+         <rtti>off <rtti>on
+         ;
+generators.override builtin.lib-generator : emscripten.prebuilt ;
+generators.override emscripten.searched-lib-generator : searched-lib-generator ;
+ 
+ type.set-generated-target-suffix EXE : <toolset>emscripten : "js" ;
+ type.set-generated-target-suffix OBJ : <toolset>emscripten : "bc" ;
+ 
@@ -0,0 +1,99 @@
+diff --git a/src/Message/Message_PrinterSystemLog.cxx b/src/Message/Message_PrinterSystemLog.cxx
+index 0c82c2167..a2e9e6d68 100644
+--- a/src/Message/Message_PrinterSystemLog.cxx
+++ b/src/Message/Message_PrinterSystemLog.cxx
+@@ -55,27 +55,6 @@
+     return ANDROID_LOG_DEBUG;
+   }
+ #elif defined(__EMSCRIPTEN__)
+-  #include <emscripten/emscripten.h>
+-
+-  //! Print message to console.debug().
+-  EM_JS(void, occJSConsoleDebug, (const char* theStr), {
+-    console.debug(UTF8ToString(theStr));
+-  });
+-
+-  //! Print message to console.info().
+-  EM_JS(void, occJSConsoleInfo, (const char* theStr), {
+-    console.info(UTF8ToString(theStr));
+-  });
+-
+-  //! Print message to console.warn().
+-  EM_JS(void, occJSConsoleWarn, (const char* theStr), {
+-    console.warn(UTF8ToString(theStr));
+-  });
+-
+-  //! Print message to console.error().
+-  EM_JS(void, occJSConsoleError, (const char* theStr), {
+-    console.error(UTF8ToString(theStr));
+-  });
+ #else
+   #include <syslog.h>
+ 
+@@ -169,16 +148,6 @@ void Message_PrinterSystemLog::send (const TCollection_AsciiString& theString,
+ #elif defined(__ANDROID__)
+   __android_log_write (getAndroidLogPriority (theGravity), myEventSourceName.ToCString(), theString.ToCString());
+ #elif defined(__EMSCRIPTEN__)
+-  // don't use bogus emscripten_log() corrupting UNICODE strings
+-  switch (theGravity)
+-  {
+-    case Message_Trace:   occJSConsoleDebug(theString.ToCString()); return;
+-    case Message_Info:    occJSConsoleInfo (theString.ToCString()); return;
+-    case Message_Warning: occJSConsoleWarn (theString.ToCString()); return;
+-    case Message_Alarm:   occJSConsoleError(theString.ToCString()); return;
+-    case Message_Fail:    occJSConsoleError(theString.ToCString()); return;
+-  }
+-  occJSConsoleWarn (theString.ToCString());
+ #else
+   syslog (getSysLogPriority (theGravity), "%s", theString.ToCString());
+ #endif
+diff --git a/src/OSD/OSD_MemInfo.cxx b/src/OSD/OSD_MemInfo.cxx
+index 08a939beb..7c1fc79b3 100644
+--- a/src/OSD/OSD_MemInfo.cxx
+++ b/src/OSD/OSD_MemInfo.cxx
+@@ -37,15 +37,6 @@
+ 
+ #include <OSD_MemInfo.hxx>
+ 
+-#if defined(__EMSCRIPTEN__)
+-  #include <emscripten.h>
+-
+-  //! Return WebAssembly heap size in bytes.
+-  EM_JS(size_t, OSD_MemInfo_getModuleHeapLength, (), {
+-    return Module.HEAP8.length;
+-  });
+-#endif
+-
+ // =======================================================================
+ // function : OSD_MemInfo
+ // purpose  :
+@@ -156,29 +147,6 @@ void OSD_MemInfo::Update()
+   }
+ 
+ #elif defined(__EMSCRIPTEN__)
+-  if (IsActive (MemHeapUsage)
+-   || IsActive (MemWorkingSet)
+-   || IsActive (MemWorkingSetPeak))
+-  {
+-    // /proc/%d/status is not emulated - get more info from mallinfo()
+-    const struct mallinfo aMI = mallinfo();
+-    if (IsActive (MemHeapUsage))
+-    {
+-      myCounters[MemHeapUsage] = aMI.uordblks;
+-    }
+-    if (IsActive (MemWorkingSet))
+-    {
+-      myCounters[MemWorkingSet] = aMI.uordblks;
+-    }
+-    if (IsActive (MemWorkingSetPeak))
+-    {
+-      myCounters[MemWorkingSetPeak] = aMI.usmblks;
+-    }
+-  }
+-  if (IsActive (MemVirtual))
+-  {
+-    myCounters[MemVirtual] = OSD_MemInfo_getModuleHeapLength();
+-  }
+ #elif (defined(__linux__) || defined(__linux))
+   if (IsActive (MemHeapUsage))
+   {
@@ -0,0 +1,81 @@
+diff --git a/COLLADABaseUtils/include/COLLADABUhash_map.h b/COLLADABaseUtils/include/COLLADABUhash_map.h
+index 8ab0fb9b..12503bfb 100644
+--- a/COLLADABaseUtils/include/COLLADABUhash_map.h
+++ b/COLLADABaseUtils/include/COLLADABUhash_map.h
+@@ -32,9 +32,9 @@
+             #include <unordered_map>
+             #include <unordered_set>
+ 
+-            #define COLLADABU_HASH_MAP std::tr1::unordered_map
+-			#define COLLADABU_HASH_MULTIMAP std::tr1::unordered_multimap
+-            #define COLLADABU_HASH_SET std::tr1::unordered_set
+            #define COLLADABU_HASH_MAP std::unordered_map
+			#define COLLADABU_HASH_MULTIMAP std::unordered_multimap
+            #define COLLADABU_HASH_SET std::unordered_set
+             #define COLLADABU_HASH_NAMESPACE_OPEN std { namespace tr1
+             #define COLLADABU_HASH_NAMESPACE_CLOSE }
+             #define COLLADABU_HASH_FUN hash
+@@ -50,12 +50,12 @@
+             #define COLLADABU_HASH_FUN hash
+         #endif
+     #elif defined(__MINGW32__) || defined(__MINGW64__)
+-        #include <tr1/unordered_map>
+-        #include <tr1/unordered_set>
+        #include <unordered_map>
+        #include <unordered_set>
+ 
+-        #define COLLADABU_HASH_MAP std::tr1::unordered_map
+-        #define COLLADABU_HASH_MULTIMAP std::tr1::unordered_multimap
+-        #define COLLADABU_HASH_SET std::tr1::unordered_set
+        #define COLLADABU_HASH_MAP std::unordered_map
+        #define COLLADABU_HASH_MULTIMAP std::unordered_multimap
+        #define COLLADABU_HASH_SET std::unordered_set
+         #define COLLADABU_HASH_NAMESPACE_OPEN std { namespace tr1
+         #define COLLADABU_HASH_NAMESPACE_CLOSE }
+         #define COLLADABU_HASH_FUN hash
+@@ -107,12 +107,12 @@
+         #define COLLADABU_HASH_NAMESPACE_CLOSE
+         #define COLLADABU_HASH_FUN hash
+     #else
+-        #include <tr1/unordered_map>
+-        #include <tr1/unordered_set>
+        #include <unordered_map>
+        #include <unordered_set>
+ 
+-		#define COLLADABU_HASH_MAP std::tr1::unordered_map
+-		#define COLLADABU_HASH_MULTIMAP std::tr1::unordered_multimap
+-        #define COLLADABU_HASH_SET std::tr1::unordered_set
+		#define COLLADABU_HASH_MAP std::unordered_map
+		#define COLLADABU_HASH_MULTIMAP std::unordered_multimap
+        #define COLLADABU_HASH_SET std::unordered_set
+         #define COLLADABU_HASH_NAMESPACE_OPEN std { namespace tr1
+         #define COLLADABU_HASH_NAMESPACE_CLOSE }
+         #define COLLADABU_HASH_FUN hash
+diff --git a/common/libBuffer/include/CommonFWriteBufferFlusher.h b/common/libBuffer/include/CommonFWriteBufferFlusher.h
+index c7af45b2..fac4f133 100644
+--- a/common/libBuffer/include/CommonFWriteBufferFlusher.h
+++ b/common/libBuffer/include/CommonFWriteBufferFlusher.h
+@@ -15,12 +15,12 @@
+ 
+ #if (defined(WIN64) || defined(_WIN64) || defined(__WIN64__)) || (defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__APPLE__))
+ #if defined(__GNUC__) && !defined(_LIBCPP_VERSION)
+-#	include <tr1/unordered_map>
+#	include <unordered_map>
+ #else
+ #	include <unordered_map>
+ #endif
+ #else
+-#	include <tr1/unordered_map>
+#	include <unordered_map>
+ #endif
+ 
+ #ifdef _LIBCPP_VERSION
+@@ -58,7 +58,7 @@ namespace Common
+ #else
+ 		typedef __int64 FilePosType;
+ #endif
+-	typedef std::tr1::unordered_map<MarkId, FilePosType > MarkIdToFilePos;
+	typedef std::unordered_map<MarkId, FilePosType > MarkIdToFilePos;
+ 
+ 	public:
+ 		static const size_t DEFAUL_BUFFER_SIZE = 64*1024;
@@ -0,0 +1,18 @@
+package:
+  name: ifcopenshell
+  version: 0.7.0
+
+source:
+  path: IfcOpenShell
+
+build:
+  script: |
+    python nix/build-all.py --without-hdf5 --without-opencollada --without-swig --without-pcre -v --wasm --py310 IfcOpenShell-Python
+    cp pyodide/setup.py .
+
+about:
+  home: http://ifcopenshell.org
+  license: LGPL-3.0-or-later
+  summary: |
+    IfcOpenShell is an open source (LGPL) software library for 
+    working with the Industry Foundation Classes (IFC) file format.
@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(name='IfcOpenShell',
+      version='0.7.0',
+      description='IfcOpenShell is an open source (LGPL) software library for working with the Industry Foundation Classes (IFC) file format.',
+      author='Thomas Krijnen',
+      author_email='thomas@aecgeeks.com',
+      url='http://ifcopenshell.org',
+      packages=find_packages(),
+      package_data={'': ['*.so']},
+)
@@ -0,0 +1 @@
+.tox
@@ -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
@@ -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.
@@ -0,0 +1,2 @@
+include src/bcf/v2/xsd/*.xsd
+include src/bcf/v3/xsd/*.xsd
@@ -0,0 +1,37 @@
+.PHONY: test
+test:
+	tox
+
+.PHONY: qa
+qa:
+	black .
+	isort .
+	pylint ./src --output-format=colorized
+
+.PHONY: typecheck
+typecheck:
+	mypy src/bcf
+
+.PHONY: license
+license:
+	copyright-header --license LGPL3 --copyright-holder "Andrea Ghensi <andrea.ghensi@gmail.com>" --copyright-year "2022" --copyright-software "IfcOpenShell" --copyright-software-description "BCF XML file handling" -a ./ -o ./
+
+.PHONY: coverage
+coverage:
+	coverage run --source bcf -m pytest tests
+	coverage html
+	xdg-open htmlcov/index.html
+
+.PHONY: clean
+clean:
+	rm -rf htmlcov
+
+# TODO: make this based on xsd file presence
+.PHONY: models
+models:
+	cd src && xsdata generate -p bcf.v2.model --unnest-classes --kw-only --slots -ds Google bcf/v2/xsd
+	cd src && xsdata generate -p bcf.v3.model --unnest-classes --kw-only --slots -ds Google bcf/v3/xsd
+
+# .PHONY
+# api:
+#     openapi-python-client generate --url https://api.swaggerhub.com/apis/buildingSMART/BCF/3.0
@@ -1,64 +1,54 @@
 # bcf

-A simple Python implementation of BCF. The data model is described in `data.py`.
+A simple Python implementation of BCF.
 Manipulation of BCF-XML is available via `bcfxml.py` and manipulation of BCF-API
 is available via `bcfapi.py`.

- - BCF-XML version 2.1: Fully supported
- - BCF-API version 2.1: Not supported, will probably tackle this after BCF-API v3.0
- - BCF-XML version 3.0: Almost fully supported, except for the documents module
- - BCF-API version 3.0: Almost fully supported, except for two requests.
+It tries to support BCF-XML version 2.1 and 3.0, and BCF-API 3.0.

 ## bcfxml

-The `bcfxml` module lets you interact with the BCF-XML standard.
+The `bcfxml.load` function lets you read a BCF-XML file.
+It takes care of using the right version based on the "bcf.version" file contained in the BCF package.
+
+The BCF files are extracted and parsed on-demand, and edits are stored in memory until you call the `save` method.

 ```python
-from bcf import bcfxml
-
+from bcf.bcfxml import load

 # Load a project
-bcfxml = bcfxml.load("/path/to/file.bcf")
+with load("/path/to/file.bcf") as bcfxml:
+    project = bcfxml.project
+    print(project.name)

+    # To edit a project, just modify the object directly
+    bcfxml.project.name = "New name"

-# The project is also stored in the module
-# project == bcfxml.project
-project=bcfxml.get_project()
-print(project.name)
+    # Get a dictionary of topics
+    topics = bcfxml.topics

-# To edit a project, just modify the object directly
-bcfxml.project.name = "New name"
-bcfxml.edit_project()
+    for topic_handler in bcfxml.topics:
+        topic = topic_handler.topic
+        print("Topic guid is", topic.guid)
+        print("Topic title is", topic.title)

-# The BCF file is extracted to this temporary directory
-print(bcfxml.filepath)
+        # Fetch extra data about a topic
+        header = topic_handler.header
+        comments = topic_handler.comments
+        viewpoints = topic_handler.viewpoints

-# Get a dictionary of topics
-topics = bcfxml.get_topics()
+        for comment in comments:
+            print(comment.guid)
+            print(comment.comment)
+            print(comment.author)

-# Note: topics == bcfxml.topics
-for guid, topic in bcfxml.topics.items():
-    print("Topic guid is", guid)
-    print("Topic guid is", topic.guid)
-    print("Topic title is", topic.title)
+    # Get a particular topic
+    topic = bcfxml.get_topic(guid)

-    # Fetch extra data about a topic
-    header = bcfxml.get_header(guid)
-    comments = bcfxml.get_comments(guid)
-    viewpoints = bcfxml.get_viewpoints(guid)
+    # Modify a topic
+    topic.title = "New title"

-    # Note: comments == topic.comments, and so on
-    for comment_guid, comment in comments.items():
-        print(comment_guid)
-        print(comment.comment)
-        print(comment.author)
-
-# Get a particular topic
-topic = bcfxml.get_topic(guid)
-
-# Modify a topic
-topic.title = "New title"
-bcfxml.edit_topic(topic)
+    bcfxml.save()
 ```

 ## bcfapi
@@ -66,36 +56,29 @@ bcfxml.edit_topic(topic)
 The `bcfapi` module lets you interact with the BCF-API standard.

 ```python
-from bcf.v3.bcfapi import Client
+from bcf.v3.bcfapi import FoundationClient, BcfClient

-client_id = "YOUR_CLIENT_ID"
-client_secret = "YOUR_CLIENT_SECRET"
-
-client = Client(client_id, client_secret)
-client.set_urls(base_url="OPENCDE_BASEURL")
-auth_methods = client.get_auth_methods()
+foundation_client = FoundationClient("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET", "OPENCDE_BASEURL")
+auth_methods = foundation_client.get_auth_methods()

 # Our library currently only implements the authorization_code flow
 if "authorization_code" in auth_methods:
-    client.login()
+    foundation_client.login()

-versions = client.get_versions()
+bcf_client = BcfClient(foundation_client)

+versions = foundation_client.get_versions()
+for version in versions:
 if "3.0" in versions:
-    client.set_version(version="3.0")
+    if version["api_id"] == "bcf" and version["version_id"] == "3.0":
+        bcf_client.set_version(version)

-data = client.get_projects()
+data = bcf_client.get_projects()
 print(data)
 project_id = data[0]["project_id"]
 print(project_id)
-data = client.get_project(project_id)
+data = bcf_client.get_project(project_id)
 print(data)
-data = client.get_extensions(project_id)
+data = bcf_client.get_extensions(project_id)
 print(data)
 ```
-
-## Todo List 
-The remaining work that needs to be completed in `bcfxml.py` and `bcfapi.py`.
-  * For `bcfxml.py` two xsds support is remaining namely 'documents.xsd` and `extensions.xsd`.
-  * For `bcfapi.py` two requests that are `get_topics` and `get_comments` are remaining.
-
@@ -1,42 +0,0 @@
-import os.path
-import zipfile
-import tempfile
-from xml.dom import minidom
-
-
-def load(filepath):
-    filepath = extract_project(filepath)
-    if os.path.isfile(os.path.join(filepath, "bcf.version")):
-        version_path = os.path.join(filepath, "bcf.version")
-        version_id = get_version(version_path)
-        # TODO: we actually coded it for 2.1, let's check the difference between 2.0 and 2.1
-        if version_id == "2.1" or version_id == "2.0":
-            from bcf.v2.bcfxml import BcfXml
-
-            bcfxml = BcfXml()
-            bcfxml.filepath = filepath
-            return bcfxml
-        elif version_id == "3.0":
-            from bcf.v3.bcfxml import BcfXml
-
-            bcfxml = BcfXml()
-            bcfxml.filepath = filepath
-            return bcfxml
-        else:
-            raise Exception(f"Version {version_id} not supported.")
-
-
-def get_version(version_path):
-    xmlparse = minidom.parse(version_path)
-    version_el = xmlparse.getElementsByTagName("Version")[0]
-    version = version_el.getAttribute("VersionId")
-    return version
-
-
-def extract_project(filepath):
-    if not filepath:
-        return
-    zip_file = zipfile.ZipFile(filepath)
-    filepath = tempfile.mkdtemp()
-    zip_file.extractall(filepath)
-    return filepath
@@ -1,771 +0,0 @@
-import os
-import uuid
-import shutil
-import zipfile
-import logging
-import tempfile
-import bcf.v2.data
-from datetime import datetime
-from xml.dom import minidom
-from xmlschema import XMLSchema
-from contextlib import contextmanager
-from shutil import copyfile
-
-
-cwd = os.path.dirname(os.path.realpath(__file__))
-
-
-@contextmanager
-def cd(newdir):
-    prevdir = os.getcwd()
-    os.chdir(os.path.expanduser(newdir))
-    try:
-        yield
-    finally:
-        os.chdir(prevdir)
-
-
-class BcfXml:
-    def __init__(self):
-        self.filepath = None
-        self.logger = logging.getLogger("bcfxml")
-        self.author = "john@doe.com"
-        self.project = bcf.v2.data.Project()
-        self.version = "2.1"
-        self.topics = {}
-
-    def new_project(self):
-        self.project.project_id = str(uuid.uuid4())
-        self.project.name = "New Project"
-        self.topics = {}
-        if self.filepath:
-            self.close_project()
-        self.filepath = tempfile.mkdtemp()
-        self.edit_project()
-        self.edit_version()
-
-    def get_project(self, filepath=None):
-        if not filepath:
-            return self.project
-        if os.path.isfile(os.path.join(self.filepath, "project.bcfp")):
-            data = self._read_xml("project.bcfp", "project.xsd")
-            self.project.extension_schema = data["ExtensionSchema"]
-            if "Project" in data:
-                self.project.project_id = data["Project"]["@ProjectId"]
-                self.project.name = data["Project"].get("Name")
-        return self.project
-
-    def edit_project(self):
-        self.document = minidom.Document()
-        root = self._create_element(self.document, "ProjectExtension")
-        project = self._create_element(root, "Project", {"ProjectId": self.project.project_id})
-        self._create_element(project, "Name", text=self.project.name)
-        self._create_element(root, "ExtensionSchema", text="extensions.xsd")
-        with open(os.path.join(self.filepath, "project.bcfp"), "wb") as f:
-            f.write(self.document.toprettyxml(encoding="utf-8"))
-
-    def save_project(self, filepath):
-        with cd(self.filepath):
-            zip_file = zipfile.ZipFile(filepath, "w", zipfile.ZIP_DEFLATED)
-            for root, dirs, files in os.walk("./"):
-                for file in files:
-                    zip_file.write(os.path.join(root, file))
-            zip_file.close()
-
-    def get_version(self):
-        data = self._read_xml("bcf.version", "version.xsd")
-        self.version = data["@VersionId"]
-        return self.version
-
-    def edit_version(self):
-        self.document = minidom.Document()
-        root = self._create_element(self.document, "Version", {"VersionId": self.version})
-        version = self._create_element(root, "DetailedVersion", text=self.version)
-        with open(os.path.join(self.filepath, "bcf.version"), "wb") as f:
-            f.write(self.document.toprettyxml(encoding="utf-8"))
-
-    def get_topics(self):
-        self.topics = {}
-        topics = []
-        subdirs = []
-        for (dirpath, dirnames, filenames) in os.walk(self.filepath):
-            subdirs = dirnames
-            break
-        for subdir in subdirs:
-            try:
-                uuid.UUID(subdir)
-            except ValueError:
-                continue
-            if not os.path.exists(os.path.join(self.filepath, subdir, "markup.bcf")):
-                continue
-            self.topics[subdir] = self.get_topic(subdir)
-        return self.topics
-
-    def get_header(self, guid):
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        if "Header" not in data:
-            return
-        header = bcf.v2.data.Header()
-        for item in data["Header"]["File"]:
-            header_file = bcf.v2.data.HeaderFile()
-            optional_keys = {
-                "filename": "Filename",
-                "date": "Date",
-                "reference": "Reference",
-                "ifc_project": "@IfcProject",
-                "ifc_spatial_structure_element": "@IfcSpatialStructureElement",
-                "is_external": "@isExternal",
-            }
-            for key, value in optional_keys.items():
-                if value in item:
-                    setattr(header_file, key, item[value])
-            header.files.append(header_file)
-        self.topics[guid].header = header
-        return header
-
-    def get_topic(self, guid):
-        if guid in self.topics:
-            return self.topics[guid]
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        topic = bcf.v2.data.Topic()
-        self.topics[guid] = topic
-
-        mandatory_keys = {
-            "guid": "@Guid",
-            "title": "Title",
-            "creation_date": "CreationDate",
-            "creation_author": "CreationAuthor",
-        }
-        for key, value in mandatory_keys.items():
-            setattr(topic, key, data["Topic"][value])
-
-        optional_keys = {
-            "priority": "Priority",
-            "index": "Index",
-            "labels": "Labels",
-            "reference_links": "ReferenceLink",
-            "modified_date": "ModifiedDate",
-            "modified_author": "ModifiedAuthor",
-            "due_date": "DueDate",
-            "assigned_to": "AssignedTo",
-            "stage": "Stage",
-            "description": "Description",
-            "topic_status": "@TopicStatus",
-            "topic_type": "@TopicType",
-        }
-        for key, value in optional_keys.items():
-            if value in data["Topic"]:
-                setattr(topic, key, data["Topic"][value])
-
-        if "BimSnippet" in data["Topic"]:
-            bim_snippet = bcf.v2.data.BimSnippet()
-            keys = {
-                "snippet_type": "@SnippetType",
-                "is_external": "@IsExternal",
-                "reference": "Reference",
-                "reference_schema": "ReferenceSchema",
-            }
-            for key, value in keys.items():
-                if value in data["Topic"]["BimSnippet"]:
-                    setattr(bim_snippet, key, data["Topic"]["BimSnippet"][value])
-            topic.bim_snippet = bim_snippet
-
-        if "DocumentReference" in data["Topic"]:
-            for item in data["Topic"]["DocumentReference"]:
-                document_reference = bcf.v2.data.DocumentReference()
-                keys = {
-                    "referenced_document": "ReferencedDocument",
-                    "is_external": "@IsExternal",
-                    "guid": "@Guid",
-                    "description": "Description",
-                }
-                for key, value in keys.items():
-                    if value in item:
-                        setattr(document_reference, key, item[value])
-                topic.document_references.append(document_reference)
-
-        if "RelatedTopic" in data["Topic"]:
-            for item in data["Topic"]["RelatedTopic"]:
-                related_topic = bcf.v2.data.RelatedTopic()
-                related_topic.guid = item["@Guid"]
-                topic.related_topics.append(related_topic)
-        return topic
-
-    def add_topic(self, topic=None):
-        if topic is None:
-            topic = bcf.v2.data.Topic()
-        if not topic.guid:
-            topic.guid = str(uuid.uuid4())
-        if not topic.title:
-            topic.title = "New Topic"
-        os.mkdir(os.path.join(self.filepath, topic.guid))
-        self.edit_topic(topic)
-        return topic
-
-    def edit_topic(self, topic):
-        if not topic.creation_date:
-            topic.creation_date = datetime.utcnow().isoformat()
-            topic.creation_author = self.author
-        else:
-            topic.modified_date = datetime.utcnow().isoformat()
-            topic.modified_author = self.author
-
-        self.document = minidom.Document()
-        root = self._create_element(self.document, "Markup")
-
-        self.write_header(topic.header, root)
-
-        topic_el = self._create_element(
-            root,
-            "Topic",
-            {
-                "Guid": topic.guid,
-                "TopicType": topic.topic_type,
-                "TopicStatus": topic.topic_status,
-            },
-        )
-
-        for reference_link in topic.reference_links:
-            self._create_element(topic_el, "ReferenceLink", text=reference_link)
-
-        text_map = {
-            "Title": topic.title,
-            "Priority": topic.priority,
-            "Index": topic.index,
-        }
-        for key, value in text_map.items():
-            if value:
-                self._create_element(topic_el, key, text=value)
-
-        for label in topic.labels:
-            self._create_element(topic_el, "Labels", text=label)
-
-        text_map = {
-            "CreationDate": topic.creation_date,
-            "CreationAuthor": topic.creation_author,
-            "ModifiedDate": topic.modified_date,
-            "ModifiedAuthor": topic.modified_author,
-            "DueDate": topic.due_date,
-            "AssignedTo": topic.assigned_to,
-            "Stage": topic.stage,
-            "Description": topic.description,
-        }
-        for key, value in text_map.items():
-            if value:
-                self._create_element(topic_el, key, text=value)
-
-        if topic.bim_snippet:
-            bim_snippet = self._create_element(
-                topic_el,
-                "BimSnippet",
-                {"SnippetType": topic.bim_snippet.snippet_type, "isExternal": topic.bim_snippet.is_external},
-            )
-            self._create_element(bim_snippet, "Reference", text=topic.bim_snippet.reference)
-            self._create_element(bim_snippet, "ReferenceSchema", text=topic.bim_snippet.reference_schema)
-        for reference in topic.document_references:
-            reference_el = self._create_element(
-                topic_el, "DocumentReference", {"Guid": reference.guid, "isExternal": reference.is_external}
-            )
-            self._create_element(reference_el, "ReferencedDocument", text=reference.referenced_document)
-            self._create_element(reference_el, "Description", text=reference.description)
-        for related_topic in topic.related_topics:
-            self._create_element(topic_el, "RelatedTopic", {"Guid": related_topic.guid})
-
-        self.write_comments(topic.comments, root)
-        self.write_viewpoints(topic.viewpoints, root, topic)
-
-        with open(os.path.join(self.filepath, topic.guid, "markup.bcf"), "wb") as f:
-            f.write(self.document.toprettyxml(encoding="utf-8"))
-
-    def write_header(self, header, root):
-        if not header or not header.files:
-            return
-        header_el = self._create_element(root, "Header")
-        for f in header.files:
-            file_el = self._create_element(
-                header_el,
-                "File",
-                {
-                    "IfcProject": f.ifc_project,
-                    "IfcSpatialStructureElement": f.ifc_spatial_structure_element,
-                    "isExternal": f.is_external,
-                },
-            )
-            if f.filename:
-                self._create_element(file_el, "Filename", text=f.filename)
-            if f.date:
-                self._create_element(file_el, "Date", text=f.date)
-            if f.reference:
-                self._create_element(file_el, "Reference", text=f.reference)
-
-    def write_comments(self, comments, root):
-        for comment in comments.values():
-            comment_el = self._create_element(root, "Comment", {"Guid": comment.guid})
-            text_map = {
-                "Date": comment.date,
-                "Author": comment.author,
-                "Comment": comment.comment,
-                "ModifiedDate": comment.modified_date,
-                "ModifiedAuthor": comment.modified_author,
-            }
-            for key, value in text_map.items():
-                if value:
-                    self._create_element(comment_el, key, text=value)
-            if comment.viewpoint:
-                self._create_element(comment_el, "Viewpoint", {"Guid": comment.viewpoint.guid})
-
-    def add_comment(self, topic, comment=None):
-        if comment is None:
-            comment = bcf.v2.data.Comment()
-        if not comment.guid:
-            comment.guid = str(uuid.uuid4())
-        if not comment.comment:
-            comment.comment = "'Free software' is a matter of liberty, not price. To understand the concept, you should think of 'free' as in 'free speech,' not as in 'free beer'."
-        topic.comments[comment.guid] = comment
-        self.edit_comment(comment, topic)
-
-    def edit_comment(self, comment, topic):
-        if not comment.date:
-            comment.date = datetime.utcnow().isoformat()
-            comment.author = self.author
-        else:
-            comment.modified_date = datetime.utcnow().isoformat()
-            comment.modified_author = self.author
-        self.edit_topic(topic)
-
-    def delete_comment(self, guid, topic):
-        if guid in topic.comments:
-            del topic.comments[guid]
-        self.edit_topic(topic)
-
-    def delete_topic(self, guid):
-        if guid in self.topics:
-            del self.topics[guid]
-        shutil.rmtree(os.path.join(self.filepath, guid))
-
-    def write_viewpoints(self, viewpoints, root, topic):
-        for viewpoint in viewpoints.values():
-            viewpoint_el = self._create_element(root, "Viewpoints", {"Guid": viewpoint.guid})
-            text_map = {"Viewpoint": viewpoint.viewpoint, "Snapshot": viewpoint.snapshot, "Index": viewpoint.index}
-            for key, value in text_map.items():
-                if value:
-                    self._create_element(viewpoint_el, key, text=value)
-            self.write_viewpoint(viewpoint, topic)
-
-    def write_viewpoint(self, viewpoint, topic):
-        document = minidom.Document()
-        root = self._create_element(document, "VisualizationInfo", {"Guid": viewpoint.guid})
-        self.write_viewpoint_components(viewpoint, root)
-        self.write_viewpoint_orthogonal_camera(viewpoint, root)
-        self.write_viewpoint_perspective_camera(viewpoint, root)
-        self.write_viewpoint_lines(viewpoint, root)
-        self.write_viewpoint_clipping_planes(viewpoint, root)
-        self.write_viewpoint_bitmaps(viewpoint, root)
-        with open(os.path.join(self.filepath, topic.guid, viewpoint.viewpoint), "wb") as f:
-            f.write(document.toprettyxml(encoding="utf-8"))
-
-    def write_viewpoint_components(self, viewpoint, parent):
-        if not viewpoint.components:
-            return
-        components_el = self._create_element(parent, "Components")
-        if viewpoint.components.view_setup_hints:
-            view_setup_hints = self._create_element(
-                components_el,
-                "ViewSetupHints",
-                {
-                    "SpacesVisible": viewpoint.components.view_setup_hints.spaces_visible,
-                    "SpaceBoundariesVisible": viewpoint.components.view_setup_hints.space_boundaries_visible,
-                    "OpeningsVisible": viewpoint.components.view_setup_hints.openings_visible,
-                },
-            )
-        if viewpoint.components.selection:
-            selection_el = self._create_element(components_el, "Selection")
-        for selection in viewpoint.components.selection:
-            self.write_component(selection, selection_el)
-        visibility = self._create_element(
-            components_el, "Visibility", {"DefaultVisibility": viewpoint.components.visibility.default_visibility}
-        )
-        if viewpoint.components.visibility.exceptions:
-            exceptions_el = self._create_element(visibility, "Exceptions")
-        for exception in viewpoint.components.visibility.exceptions:
-            self.write_component(exception, exceptions_el)
-        if viewpoint.components.coloring:
-            coloring_el = self._create_element(components_el, "Coloring")
-        for color in viewpoint.components.coloring:
-            color_el = self._create_element(coloring_el, "Color", {"Color": color.color})
-            for component in color.components:
-                self.write_component(component, color_el)
-
-    def write_viewpoint_orthogonal_camera(self, viewpoint, parent):
-        if not viewpoint.orthogonal_camera:
-            return
-        camera = viewpoint.orthogonal_camera
-        camera_el = self._create_element(parent, "OrthogonalCamera")
-        camera_view_point = self._create_element(camera_el, "CameraViewPoint")
-        self.write_vector(camera_view_point, camera.camera_view_point)
-        camera_direction = self._create_element(camera_el, "CameraDirection")
-        self.write_vector(camera_direction, camera.camera_direction)
-        camera_up_vector = self._create_element(camera_el, "CameraUpVector")
-        self.write_vector(camera_up_vector, camera.camera_up_vector)
-        self._create_element(camera_el, "ViewToWorldScale", text=camera.view_to_world_scale)
-
-    def write_viewpoint_perspective_camera(self, viewpoint, parent):
-        if not viewpoint.perspective_camera:
-            return
-        camera = viewpoint.perspective_camera
-        camera_el = self._create_element(parent, "PerspectiveCamera")
-        camera_view_point = self._create_element(camera_el, "CameraViewPoint")
-        self.write_vector(camera_view_point, camera.camera_view_point)
-        camera_direction = self._create_element(camera_el, "CameraDirection")
-        self.write_vector(camera_direction, camera.camera_direction)
-        camera_up_vector = self._create_element(camera_el, "CameraUpVector")
-        self.write_vector(camera_up_vector, camera.camera_up_vector)
-        self._create_element(camera_el, "FieldOfView", text=camera.field_of_view)
-
-    def write_viewpoint_lines(self, viewpoint, parent):
-        if not viewpoint.lines:
-            return
-        lines_el = self._create_element(parent, "Lines")
-        for line in viewpoint.lines:
-            line_el = self._create_element(lines_el, "Line")
-            start_point_el = self._create_element(line_el, "StartPoint")
-            self.write_vector(start_point_el, line.start_point)
-            end_point_el = self._create_element(line_el, "EndPoint")
-            self.write_vector(end_point_el, line.end_point)
-
-    def write_viewpoint_clipping_planes(self, viewpoint, parent):
-        if not viewpoint.clipping_planes:
-            return
-        planes_el = self._create_element(parent, "ClippingPlanes")
-        for plane in viewpoint.clipping_planes:
-            plane_el = self._create_element(planes_el, "ClippingPlane")
-            location_el = self._create_element(plane_el, "Location")
-            self.write_vector(location_el, plane.location)
-            direction_el = self._create_element(plane_el, "Direction")
-            self.write_vector(direction_el, plane.direction)
-
-    def write_viewpoint_bitmaps(self, viewpoint, parent):
-        if not viewpoint.bitmaps:
-            return
-        for bitmap in viewpoint.bitmaps:
-            bitmap_el = self._create_element(parent, "Bitmap")
-
-            text_map = {"Bitmap": bitmap.bitmap_format, "Reference": bitmap.reference}
-            for key, value in text_map.items():
-                self._create_element(bitmap_el, key, text=value)
-
-            location_el = self._create_element(bitmap_el, "Location")
-            self.write_vector(location_el, bitmap.location)
-            normal_el = self._create_element(bitmap_el, "Normal")
-            self.write_vector(normal_el, bitmap.normal)
-            up_el = self._create_element(bitmap_el, "Up")
-            self.write_vector(up_el, bitmap.up)
-
-            self._create_element(bitmap_el, "Height", text=bitmap.height)
-
-    def write_vector(self, parent, from_obj):
-        self._create_element(parent, "X", text=from_obj.x)
-        self._create_element(parent, "Y", text=from_obj.y)
-        self._create_element(parent, "Z", text=from_obj.z)
-
-    def write_component(self, data, parent):
-        component_el = self._create_element(parent, "Component", {"IfcGuid": data.ifc_guid})
-        text_map = {"OriginatingSystem": data.originating_system, "AuthoringToolId": data.authoring_tool_id}
-        for key, value in text_map.items():
-            if value:
-                self._create_element(component_el, key, text=value)
-
-    def add_viewpoint(self, topic, viewpoint=None):
-        if not viewpoint:
-            viewpoint = bcf.v2.data.Viewpoint()
-        if not viewpoint.guid:
-            viewpoint.guid = str(uuid.uuid4())
-        if not viewpoint.viewpoint:
-            viewpoint.viewpoint = f"{viewpoint.guid}.bcfv"
-        if viewpoint.snapshot:
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            filepath = os.path.join(topic_filepath, viewpoint.snapshot)
-            if not os.path.exists(filepath):
-                filename = viewpoint.guid + os.path.splitext(viewpoint.snapshot)[-1]
-                copyfile(viewpoint.snapshot, os.path.join(topic_filepath, filename))
-                viewpoint.snapshot = filename
-        topic.viewpoints[viewpoint.guid] = viewpoint
-        self.edit_topic(topic)
-
-    def delete_viewpoint(self, guid, topic):
-        if guid not in topic.viewpoints:
-            return
-        viewpoint = topic.viewpoints[guid]
-        if viewpoint.snapshot:
-            filepath = os.path.join(self.filepath, topic.guid, viewpoint.snapshot)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        if viewpoint.viewpoint:
-            filepath = os.path.join(self.filepath, topic.guid, viewpoint.viewpoint)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        for bitmap in viewpoint.bitmaps:
-            if not bitmap.reference:
-                continue
-            filepath = os.path.join(self.filepath, topic.guid, bitmap.reference)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        del topic.viewpoints[guid]
-        self.edit_topic(topic)
-
-    def delete_file(self, topic, index):
-        if not topic.header:
-            return
-        f = topic.header.files.pop(index)
-        filepath = os.path.join(self.filepath, topic.guid, f.reference)
-        if not f.is_external and os.path.exists(filepath):
-            os.remove(filepath)
-        self.edit_topic(topic)
-
-    def delete_bim_snippet(self, topic):
-        if not topic.bim_snippet:
-            return
-        if topic.bim_snippet.reference and not topic.bim_snippet.is_external:
-            filepath = os.path.join(self.filepath, topic.guid, topic.bim_snippet.reference)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        topic.bim_snippet = None
-        self.edit_topic(topic)
-
-    def delete_document_reference(self, topic, index):
-        document_reference = topic.document_references[index]
-        if document_reference.referenced_document and not document_reference.is_external:
-            filepath = os.path.join(self.filepath, topic.guid, document_reference.referenced_document)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        del topic.document_references[index]
-        self.edit_topic(topic)
-
-    def add_document_reference(self, topic, document_reference):
-        if os.path.exists(document_reference.referenced_document):
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            filename = os.path.basename(document_reference.referenced_document)
-            copyfile(document_reference.referenced_document, os.path.join(topic_filepath, filename))
-            document_reference.referenced_document = filename
-            document_reference.is_external = False
-        else:
-            document_reference.is_external = True
-        if not document_reference.guid:
-            document_reference.guid = str(uuid.uuid4())
-        topic.document_references.append(document_reference)
-        self.edit_topic(topic)
-
-    def add_bim_snippet(self, topic, bim_snippet):
-        if topic.bim_snippet:
-            self.delete_bim_snippet(topic)
-        if os.path.exists(bim_snippet.reference):
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            filename = os.path.basename(bim_snippet.reference)
-            copyfile(bim_snippet.reference, os.path.join(topic_filepath, filename))
-            bim_snippet.reference = filename
-            bim_snippet.is_external = False
-        else:
-            bim_snippet.is_external = True
-        topic.bim_snippet = bim_snippet
-        self.edit_topic(topic)
-
-    def add_file(self, topic, header_file):
-        if os.path.exists(header_file.reference):
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            header_file.filename = os.path.basename(header_file.reference)
-            copyfile(header_file.reference, os.path.join(topic_filepath, header_file.filename))
-            header_file.reference = header_file.filename
-            header_file.is_external = False
-        header_file.date = datetime.utcnow().isoformat()
-        if not topic.header:
-            topic.header = bcf.v2.data.Header()
-        topic.header.files.append(header_file)
-        self.edit_topic(topic)
-
-    def get_comments(self, guid):
-        comments = {}
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        if "Comment" not in data:
-            return comments
-        for item in data["Comment"]:
-            comment = bcf.v2.data.Comment()
-            mandatory_keys = {"guid": "@Guid", "date": "Date", "author": "Author", "comment": "Comment"}
-            for key, value in mandatory_keys.items():
-                setattr(comment, key, item[value])
-            optional_keys = {"modified_date": "ModifiedDate", "modified_author": "ModifiedAuthor"}
-            for key, value in optional_keys.items():
-                if value in item:
-                    setattr(comment, key, item[value])
-            if "Viewpoint" in item:
-                viewpoint = bcf.v2.data.Viewpoint()
-                viewpoint.guid = item["Viewpoint"]["@Guid"]
-                comment.viewpoint = viewpoint
-            comments[comment.guid] = comment
-        self.topics[guid].comments = comments
-        return comments
-
-    def get_viewpoints(self, guid):
-        viewpoints = {}
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        if "Viewpoints" not in data:
-            return viewpoints
-        for item in data["Viewpoints"]:
-            viewpoint = self.get_viewpoint(item, guid)
-            viewpoints[viewpoint.guid] = viewpoint
-        self.topics[guid].viewpoints = viewpoints
-        return viewpoints
-
-    def get_viewpoint(self, data, topic_guid):
-        viewpoint = bcf.v2.data.Viewpoint()
-        viewpoint.guid = data["@Guid"]
-        optional_keys = {"viewpoint": "Viewpoint", "snapshot": "Snapshot", "index": "Index"}
-        for key, value in optional_keys.items():
-            if value in data:
-                setattr(viewpoint, key, data[value])
-        visinfo = self._read_xml(os.path.join(topic_guid, viewpoint.viewpoint), "visinfo.xsd")
-        viewpoint.components = self.get_viewpoint_components(visinfo)
-        viewpoint.orthogonal_camera = self.get_viewpoint_orthogonal_camera(visinfo)
-        viewpoint.perspective_camera = self.get_viewpoint_perspective_camera(visinfo)
-        viewpoint.lines = self.get_viewpoint_lines(visinfo)
-        viewpoint.clipping_planes = self.get_viewpoint_clipping_planes(visinfo)
-        viewpoint.bitmaps = self.get_viewpoint_bitmaps(visinfo)
-        return viewpoint
-
-    def get_viewpoint_components(self, visinfo):
-        if "Components" not in visinfo:
-            return None
-        components = bcf.v2.data.Components()
-        data = visinfo["Components"]
-        if "ViewSetupHints" in data:
-            view_setup_hints = bcf.v2.data.ViewSetupHints()
-            optional_keys = {
-                "spaces_visible": "@SpacesVisible",
-                "space_boundaries_visible": "@SpaceBoundariesVisible",
-                "openings_visible": "@OpeningsVisible",
-            }
-            for key, value in optional_keys.items():
-                if value in data["ViewSetupHints"]:
-                    setattr(view_setup_hints, key, data["ViewSetupHints"][value])
-            components.view_setup_hints = view_setup_hints
-        if "Selection" in data and "Component" in data["Selection"]:
-            for item in data["Selection"]["Component"]:
-                components.selection.append(self.get_component(item))
-        if "Visibility" in data:
-            component_visibility = bcf.v2.data.ComponentVisibility()
-            if "@DefaultVisibility" in data["Visibility"]:
-                component_visibility.default_visibility = data["Visibility"]["@DefaultVisibility"]
-            if "Exceptions" in data["Visibility"] and "Component" in data["Visibility"]["Exceptions"]:
-                for item in data["Visibility"]["Exceptions"]["Component"]:
-                    component_visibility.exceptions.append(self.get_component(item))
-            components.visibility = component_visibility
-        if "Coloring" in data and "Color" in data["Coloring"]:
-            for item in data["Coloring"]["Color"]:
-                color = bcf.v2.data.Color()
-                color.color = item["@Color"]
-                for item2 in item["Component"]:
-                    color.components.append(self.get_component(item2))
-                components.coloring.append(color)
-        return components
-
-    def get_viewpoint_orthogonal_camera(self, visinfo):
-        if "OrthogonalCamera" not in visinfo:
-            return None
-        camera = bcf.v2.data.OrthogonalCamera()
-        data = visinfo["OrthogonalCamera"]
-        self.set_vector(camera.camera_view_point, data["CameraViewPoint"])
-        self.set_vector(camera.camera_direction, data["CameraDirection"])
-        self.set_vector(camera.camera_up_vector, data["CameraUpVector"])
-        camera.view_to_world_scale = data["ViewToWorldScale"]
-        return camera
-
-    def get_viewpoint_perspective_camera(self, visinfo):
-        if "PerspectiveCamera" not in visinfo:
-            return None
-        camera = bcf.v2.data.PerspectiveCamera()
-        data = visinfo["PerspectiveCamera"]
-        self.set_vector(camera.camera_view_point, data["CameraViewPoint"])
-        self.set_vector(camera.camera_direction, data["CameraDirection"])
-        self.set_vector(camera.camera_up_vector, data["CameraUpVector"])
-        camera.field_of_view = data["FieldOfView"]
-        return camera
-
-    def get_viewpoint_lines(self, visinfo):
-        if "Lines" not in visinfo:
-            return []
-        lines = []
-        for item in visinfo["Lines"]["Line"]:
-            line = bcf.v2.data.Line()
-            self.set_vector(line.start_point, item["StartPoint"])
-            self.set_vector(line.end_point, item["EndPoint"])
-            lines.append(line)
-        return lines
-
-    def get_viewpoint_clipping_planes(self, visinfo):
-        if "ClippingPlanes" not in visinfo:
-            return []
-        planes = []
-        for item in visinfo["ClippingPlanes"]["ClippingPlane"]:
-            plane = bcf.v2.data.ClippingPlane()
-            self.set_vector(plane.location, item["Location"])
-            self.set_vector(plane.direction, item["Direction"])
-            planes.append(plane)
-        return planes
-
-    def get_viewpoint_bitmaps(self, visinfo):
-        if "Bitmap" not in visinfo:
-            return []
-        bitmaps = []
-        for item in visinfo["Bitmap"]:
-            bitmap = bcf.v2.data.Bitmap()
-            bitmap.reference = item["Reference"]
-            bitmap.bitmap_format = item["Bitmap"].upper()
-            self.set_vector(bitmap.location, item["Location"])
-            self.set_vector(bitmap.normal, item["Normal"])
-            self.set_vector(bitmap.up, item["Up"])
-            bitmap.height = item["Height"]
-            bitmaps.append(bitmap)
-        return bitmaps
-
-    def set_vector(self, to_obj, from_xml):
-        to_obj.x = from_xml["X"]
-        to_obj.y = from_xml["Y"]
-        to_obj.z = from_xml["Z"]
-
-    def get_component(self, data):
-        component = bcf.v2.data.Component()
-        optional_keys = {
-            "originating_system": "OriginatingSystem",
-            "authoring_tool_id": "AuthoringToolId",
-            "ifc_guid": "@IfcGuid",
-        }
-        for key, value in optional_keys.items():
-            if value in data:
-                setattr(component, key, data[value])
-        return component
-
-    def close_project(self):
-        shutil.rmtree(self.filepath)
-
-    def _read_xml(self, filename, xsd):
-        schema = XMLSchema(os.path.join(cwd, "xsd", xsd))
-        filepath = os.path.join(self.filepath, filename)
-        (data, errors) = schema.to_dict(filepath, validation="lax")
-        for error in errors:
-            self.logger.error(error)
-        return data
-
-    def _create_element(self, parent, name, attributes={}, text=None):
-        element = self.document.createElement(name)
-        for key, value in attributes.items():
-            if isinstance(value, bool):
-                element.setAttribute(key, str(value).lower())
-            elif value:
-                element.setAttribute(key, value)
-        if text is not None:
-            text = self.document.createTextNode(str(text))
-            element.appendChild(text)
-        parent.appendChild(element)
-        return element
-
-    def __del__(self):
-        self.close_project()
@@ -1,179 +0,0 @@
-class Project:
-    def __init__(self):
-        self.project_id = ""
-        self.name = ""
-        self.extension_schema = ""
-
-
-class BimSnippet:
-    def __init__(self):
-        self.snippet_type = None
-        self.is_external = False
-        self.reference = None
-        self.reference_schema = None
-
-
-class DocumentReference:
-    def __init__(self):
-        self.referenced_document = None
-        self.description = None
-        self.guid = None
-        self.is_external = False
-
-
-class RelatedTopic:
-    def __init__(self):
-        self.guid = None
-
-
-class HeaderFile:
-    def __init__(self):
-        self.filename = None
-        self.date = None
-        self.reference = None
-        self.ifc_project = None
-        self.ifc_spatial_structure_element = None
-        self.is_external = True
-
-
-class Header:
-    def __init__(self):
-        self.files = []
-
-
-class Topic:
-    def __init__(self):
-        self.reference_links = []
-        self.title = ""
-        self.priority = None
-        self.index = None  # Deprecated, stored, but ignored
-        self.labels = []
-        self.creation_date = None
-        self.creation_author = None
-        self.modified_date = None
-        self.modified_author = None
-        self.due_date = None
-        self.assigned_to = None
-        self.stage = None
-        self.description = None
-        self.bim_snippet = None
-        self.document_references = []
-        self.related_topics = []
-        self.topic_status = None
-        self.topic_type = None
-        self.guid = None
-
-        self.header = None
-        self.comments = {}
-        self.viewpoints = {}
-
-
-class Comment:
-    def __init__(self):
-        self.guid = None
-        self.date = None
-        self.author = None
-        self.comment = None
-        self.viewpoint = None
-        self.modified_date = None
-        self.modified_author = None
-        self.topic_guid = None  # Part of BCF-API
-
-
-class ViewSetupHints:
-    def __init__(self):
-        self.spaces_visible = False
-        self.space_boundaries_visible = False
-        self.openings_visible = False
-
-
-class Component:
-    def __init__(self):
-        self.originating_system = None
-        self.authoring_tool_id = None
-        self.ifc_guid = None
-
-
-class ComponentVisibility:
-    def __init__(self):
-        self.exceptions = []
-        self.default_visibility = False
-
-
-class Color:
-    def __init__(self):
-        self.color = None
-        self.components = []
-
-
-class Components:
-    def __init__(self):
-        self.view_setup_hints = None
-        self.selection = []
-        self.visibility = None
-        self.coloring = []
-
-
-class Point:
-    def __init__(self):
-        self.x = 0
-        self.y = 0
-        self.z = 0
-
-
-class Direction(Point):
-    pass
-
-
-class OrthogonalCamera:
-    def __init__(self):
-        self.camera_view_point = Point()
-        self.camera_direction = Direction()
-        self.camera_up_vector = Direction()
-        self.view_to_world_scale = 1.0
-
-
-class PerspectiveCamera:
-    def __init__(self):
-        self.camera_view_point = Point()
-        self.camera_direction = Direction()
-        self.camera_up_vector = Direction()
-        self.field_of_view = 60.0
-
-
-class Line:
-    def __init__(self):
-        self.start_point = Point()
-        self.end_point = Point()
-
-
-class ClippingPlane:
-    def __init__(self):
-        self.location = Point()
-        self.direction = Direction()
-
-
-class Bitmap:
-    def __init__(self):
-        self.reference = ""  # Only in BCF-XML
-        self.bitmap_data = None  # Only in BCF-API
-        self.bitmap_format = "PNG"  # Enum of png or jpg
-        self.location = Point()
-        self.normal = Direction()
-        self.up = Direction()
-        self.height = 1.0
-
-
-class Viewpoint:
-    def __init__(self):
-        self.guid = None
-        self.viewpoint = None
-        self.snapshot = None
-        self.index = None
-
-        self.components = None  # It's not a list, despite the plural name
-        self.orthogonal_camera = None
-        self.perspective_camera = None
-        self.lines = []
-        self.clipping_planes = []
-        self.bitmaps = []
@@ -1,540 +0,0 @@
-import uuid
-import time
-import json
-import urllib
-import requests
-import webbrowser
-import http.server
-import base64
-
-
-client_id, client_secret = "", ""
-
-
-class OAuthReceiver(http.server.BaseHTTPRequestHandler):
-    def do_GET(self):
-        query = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
-        self.server.auth_code = query.get("code", [""])[0]
-        self.server.auth_state = query.get("state", [""])[0]
-        self.send_response(200)
-        self.send_header("Content-type", "text/plain")
-        self.end_headers()
-        self.wfile.write("You have now authenticated :) You may now close this browser window.".encode("utf-8"))
-
-
-class Client:
-    def __init__(self, client_id, client_secret):
-        self.baseurl = None
-        self.access_token = ""
-        self.refresh_token = ""
-        self.access_token_expires_on = time.time()
-        self.refresh_token_expires_on = float("inf")
-        self.auth_endpoint = None
-        self.token_endpoint = None
-        self.client_id = client_id
-        self.client_secret = client_secret
-        self.version_ids = {}
-        self.version = None
-        self.auth_method = None
-        self.redirect_uri = None
-        self.api_baseurl = None
-
-    def get(self, endpoint, params=None, is_auth_required=False):
-        headers = {"Authorization": "Bearer " + self.get_access_token()}
-        return requests.get(f"{self.api_baseurl}{endpoint}", headers=headers, params=params or None).json()
-
-    def post(self, endpoint, data=None, params=None):
-        headers = {
-            "Authorization": "Bearer " + self.get_access_token(),
-            "Content-type": "application/json",
-        }
-        resp = requests.post(
-            f"{self.api_baseurl}{endpoint}",
-            headers=headers,
-            params=params or None,
-            data=data or None,
-        )
-        return resp.status_code, resp.text
-
-    def put(self, endpoint, data=None, params=None):
-        headers = {
-            "Authorization": "Bearer " + self.get_access_token(),
-            "Content-type": "application/json",
-        }
-        resp = requests.put(
-            f"{self.baseurl}{endpoint}",
-            headers=headers,
-            params=params or None,
-            data=data or None,
-        )
-        return resp.status_code, resp.text
-
-    def set_urls(self, base_url=None, redirect_uri=None):
-        self.baseurl = base_url
-        self.redirect_uri = redirect_uri
-
-    def delete(self, endpoint, params=None):
-        headers = {"Authorization": "Bearer " + self.get_access_token()}
-        resp = requests.put(
-            f"{self.baseurl}{endpoint}",
-            headers=headers,
-            params=params or None,
-        )
-        return resp.status_code
-
-    def get_access_token(self):
-        if self.access_token and self.access_token_expires_on > time.time():
-            return self.access_token
-        elif self.refresh_token and self.refresh_token_expires_on > time.time():
-            self.get_refresh_token()
-        else:
-            self.login()
-        return self.access_token
-
-    def get_auth_methods(self):
-        resp = requests.get(f"{self.baseurl}opencde/1.0/auth")
-        return resp.json()["supported_oauth2_flows"]
-
-    def get_versions(self):
-        resp = requests.get(f"{self.baseurl}opencde/versions")
-        resp_values = resp.json()["versions"]
-        for version in resp_values:
-            if "api_base_url" in version:
-                self.version_ids.update({version["version_id"]: version["api_base_url"]})
-        return self.version_ids
-
-    def set_version(self, version=None):
-        self.version = version
-        self.api_baseurl = self.version_ids[self.version]
-
-    def login(self):
-        resp = requests.get(f"{self.baseurl}opencde/1.0/auth")
-        values = resp.json()
-        self.auth_endpoint = values["oauth2_auth_url"]
-        self.token_endpoint = values["oauth2_token_url"]
-
-        with http.server.HTTPServer(("", 8080), OAuthReceiver) as server:
-            state = str(uuid.uuid4())
-            query = urllib.parse.urlencode(
-                {
-                    "client_id": self.client_id,
-                    "response_type": "code",
-                    "state": state,
-                    "redirect_uri": f"http://localhost:{server.server_address[1]}/{self.redirect_uri}",
-                }
-            )
-            if "?" in self.auth_endpoint:
-                webbrowser.open(f"{self.auth_endpoint}&{query}")
-            else:
-                webbrowser.open(f"{self.auth_endpoint}?{query}")
-            server.timeout = 100
-            server.state = state
-            server.handle_request()
-            if server.auth_code and server.auth_state == state:
-                data = {
-                    "grant_type": "authorization_code",
-                    "code": server.auth_code,
-                    "redirect_uri": f"http://localhost:{server.server_address[1]}/{self.redirect_uri}",
-                }
-                auth_string = f"{self.client_id}:{self.client_secret}"
-                header_string = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
-                headers = {"Authorization": f"Basic {header_string}"}
-                self.set_tokens_from_response(requests.post(self.token_endpoint, data=data, headers=headers))
-
-    def get_refresh_token(self):
-        self.set_tokens_from_response(
-            requests.post(
-                self.token_endpoint,
-                params={
-                    "grant_type": "refresh_token",
-                    "refresh_token": self.refresh_token,
-                },
-            ).json()
-        )
-
-    def get_new_access_token(self):
-        auth_string = f"{self.client_id}:{self.client_secret}"
-        header_string = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
-        headers = {"Authorization": f"Basic {header_string}"}
-        self.set_tokens_from_response(
-            requests.post(
-                self.token_endpoint,
-                data={
-                    "grant_type": "refresh_token",
-                    "refresh_token": self.refresh_token,
-                },
-                headers=headers,
-            ).json()
-        )
-
-    def set_auth_method(self, method="authorization_code_grant"):
-        if method != "authorization_code_grant":
-            raise NotImplementedError(f"{method} not supported")
-        else:
-            self.auth_method = method
-
-    def set_tokens_from_response(self, response):
-        response = response.json()
-        self.access_token = response["access_token"]
-        self.refresh_token = response["refresh_token"]
-        self.access_token_expires_on = time.time() + response["expires_in"]
-        if "refresh_token_expires_in" in response:
-            self.refresh_token_expires_on = time.time() + response["refresh_token_expires_in"]
-
-    def get_projects(self) -> list:
-        return self.get(
-            f"/projects",
-        )
-
-    def get_project(
-        self,
-        project_id="",
-    ) -> dict:
-        return self.get(
-            f"/projects/{project_id}",
-            {
-                "project_id": project_id,
-            },
-        )
-
-    def update_project(self, project_id="", data=None) -> dict:
-        url = f"{self.baseurl}/projects/{project_id}"
-        headers = {"Authorization": "Bearer " + self.get_access_token()}
-        resp = requests.put(url, headers=headers, data=data)
-        return resp.status_code, resp.text
-
-    def get_extensions(
-        self,
-        project_id="",
-    ) -> dict:
-        return self.get(
-            f"/projects/{project_id}/extensions",
-            {
-                "project_id": project_id,
-            },
-        )
-
-    def get_topics(
-        self,
-        project_id="",
-        topics="",
-        query_string=None,
-    ) -> list:
-        # return self.get(
-        #     f"/projects/{project_id}/topics",
-        #     {
-        #         "project_id": project_id,
-        #         "topics": topics,
-        #         "query_string": query_string,
-        #     },
-        # )
-        pass
-
-    def get_topic(self, project_id="", topic_id="") -> dict:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def create_topic(self, project_id="", data=None):
-        return self.post(f"/projects/{project_id}/topics", data=data)
-
-    def update_topic(self, project_id="", topic_id="", data=None) -> dict:
-        return self.put(f"/projects/{project_id}/topics/{topic_id}", data=data)
-
-    def delete_topic(self, project_id="", topic_id=""):
-        return self.delete(f"/projects/{project_id}/topics/{topic_id}")
-
-    def get_snippet(self, project_id="", topic_id="") -> str:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/snippet",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def update_snippet(self, project_id="", topic_id="", data=None):
-        return self.put(f"/projects/{project_id}/topics", data=data)
-
-    def get_files_information(self, project_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/files_information",
-            {
-                "project_id": project_id,
-            },
-        )
-
-    def get_files(self, project_id="", topic_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/files",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def update_files(
-        self,
-        project_id="",
-        topic_id="",
-        data=None,
-        params=None,
-    ):
-        return self.put(
-            f"/projects/{project_id}/topics/{topic_id}/files",
-            data=data,
-        )
-
-    def get_comments(self, project_id="", topic_id="") -> list:
-        pass
-
-    def create_comments(
-        self,
-        project_id="",
-        topic_id="",
-        data=None,
-        params=None,
-    ):
-        return self.post(
-            f"/projects/{project_id}/topics/{topic_id}/comments",
-            data=data,
-        )
-
-    def get_comment(self, project_id="", topic_id="", comment_id="") -> dict:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "comment_id": comment_id,
-            },
-        )
-
-    def delete_comment(self, project_id="", topic_id="", comment_id=""):
-        return self.delete(f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}")
-
-    def update_comment(
-        self,
-        project_id="",
-        topic_id="",
-        comment_id="",
-        data=None,
-    ):
-        return self.put(
-            f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}",
-            data=data,
-        )
-
-    def get_viewpoints(self, project_id="", topic_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def create_viewpoints(self, project_id="", topic_id="", data=None):
-        return self.post(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints",
-            data=data,
-        )
-
-    def get_viewpoint(self, project_id="", topic_id="", viewpoint_id="") -> dict:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "viewpoint_id": viewpoint_id,
-            },
-        )
-
-    def delete_viewpoint(
-        self,
-        project_id="",
-        topic_id="",
-        viewpoint_id="",
-    ):
-        return self.delete(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}",
-        )
-
-    def get_snapshot(self, project_id="", topic_id="", viewpoint_id="") -> str:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/snapshot",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "viewpoint_id": viewpoint_id,
-            },
-        )
-
-    def get_bitmap(self, project_id="", topic_id="", viewpoint_id="", bitmap_id="") -> str:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/bitmaps/{bitmap_id}",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "viewpoint_id": viewpoint_id,
-                "bitmap_id": bitmap_id,
-            },
-        )
-
-    def get_selection(self, project_id="", topic_id="", viewpoint_id="") -> dict:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/selection",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "viewpoint_id": viewpoint_id,
-            },
-        )
-
-    def get_coloring(self, project_id="", topic_id="", viewpoint_id="") -> dict:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/coloring",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "viewpoint_id": viewpoint_id,
-            },
-        )
-
-    def get_visibility(self, project_id="", topic_id="", viewpoint_id="") -> dict:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/visibility",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "viewpoint_id": viewpoint_id,
-            },
-        )
-
-    def get_related_topics(self, project_id="", topic_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/related_topics",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def update_related_topics(
-        self,
-        project_id="",
-        topic_id="",
-        data=None,
-    ):
-        return self.put(
-            f"/projects/{project_id}/topics/{topic_id}/related_topics",
-            data=data,
-        )
-
-    def get_document_references(self, project_id="", topic_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/document_references",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def create_document_reference(
-        self,
-        project_id="",
-        topic_id="",
-        data=None,
-    ):
-        return self.post(
-            f"/projects/{project_id}/topics/{topic_id}/document_references",
-            data=data,
-        )
-
-    def update_document_references(
-        self,
-        project_id="",
-        topic_id="",
-        document_reference_id="",
-        data=None,
-    ):
-        return self.put(
-            f"/projects/{project_id}/topics/{topic_id}/document_references/{document_reference_id}",
-            data=data,
-        )
-
-    def get_documents(self, project_id="", topic_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/documents",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def create_document(
-        self,
-        project_id="",
-        topic_id="",
-        guid=None,
-        data=None,
-    ):
-        headers = {
-            "Authorization": "Bearer " + self.get_access_token(),
-            "Content-type": "application/octet-stream",
-        }
-        response = requests.post(
-            f"/projects/{project_id}/topics/{topic_id}/documents",
-            data=data,
-            params={guid},
-            headers=headers,
-        )
-
-    def get_document(self, project_id="", topic_id="", document_id="") -> str:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/documents/{document_id}",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "document_id": document_id,
-            },
-        )
-
-    def get_topics_events(self, project_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/events",
-            {
-                "project_id": project_id,
-            },
-        )
-
-    def get_topic_events(self, project_id="", topic_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/events",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-            },
-        )
-
-    def get_comments_events(self, project_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/comments/events",
-            {
-                "project_id": project_id,
-            },
-        )
-
-    def get_comment_events(self, project_id="", topic_id="", comment_id="") -> list:
-        return self.get(
-            f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}/events",
-            {
-                "project_id": project_id,
-                "topic_id": topic_id,
-                "comment_id": comment_id,
-            },
-        )
@@ -1,827 +0,0 @@
-import os
-import uuid
-import shutil
-import zipfile
-import logging
-import tempfile
-import bcf.v3.data
-from datetime import datetime
-from xml.dom import minidom
-from xmlschema import XMLSchema
-from contextlib import contextmanager
-from shutil import copyfile
-
-cwd = os.path.dirname(os.path.realpath(__file__))
-
-
-@contextmanager
-def cd(newdir):
-    prevdir = os.getcwd()
-    os.chdir(os.path.expanduser(newdir))
-    try:
-        yield
-    finally:
-        os.chdir(prevdir)
-
-
-class BcfXml:
-    def __init__(self):
-        self.filepath = None
-        self.logger = logging.getLogger("bcfxml")
-        self.author = "john@doe.com"
-        self.project = bcf.v3.data.Project()
-        self.version = "3.0"
-        self.topics = {}
-
-    def new_project(self):
-        self.project.project_id = str(uuid.uuid4())
-        self.project.name = "New Project"
-        self.topics = {}
-        if self.filepath:
-            self.close_project()
-        self.filepath = tempfile.mkdtemp()
-        self.edit_project()
-        self.edit_version()
-
-    def get_project(self, filepath=None):
-        if os.path.isfile(os.path.join(self.filepath, "project.bcfp")):
-            data = self._read_xml("project.bcfp", "project.xsd")
-            self.project.project_id = data["Project"]["@ProjectId"]
-            self.project.name = data["Project"].get("Name")
-        return self.project
-
-    def edit_project(self):
-        self.document = minidom.Document()
-        root = self._create_element(self.document, "ProjectInfo")
-        project = self._create_element(root, "Project", {"ProjectId": self.project.project_id})
-        if self.project.name:
-            self._create_element(project, "Name", text=self.project.name)
-        with open(os.path.join(self.filepath, "project.bcfp"), "wb") as f:
-            f.write(self.document.toprettyxml(encoding="utf-8"))
-
-    def save_project(self, filepath):
-        with cd(self.filepath):
-            zip_file = zipfile.ZipFile(filepath, "w", zipfile.ZIP_DEFLATED)
-            for root, dirs, files in os.walk("./"):
-                for file in files:
-                    zip_file.write(os.path.join(root, file))
-            zip_file.close()
-
-    def get_version(self):
-        data = self._read_xml("bcf.version", "version.xsd")
-        self.version = data["@VersionId"]
-        return self.version
-
-    def edit_version(self):
-        self.document = minidom.Document()
-        root = self._create_element(self.document, "Version", {"VersionId": self.version})
-        with open(os.path.join(self.filepath, "bcf.version"), "wb") as f:
-            f.write(self.document.toprettyxml(encoding="utf-8"))
-
-    def get_topics(self):
-        self.topics = {}
-        topics = []
-        subdirs = []
-        for (dirpath, dirnames, filenames) in os.walk(self.filepath):
-            subdirs = dirnames
-            break
-        for subdir in subdirs:
-            try:
-                uuid.UUID(subdir)
-            except ValueError:
-                continue
-            if not os.path.exists(os.path.join(self.filepath, subdir, "markup.bcf")):
-                continue
-            self.topics[subdir] = self.get_topic(subdir)
-        return self.topics
-
-    def get_header(self, guid):
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        if "Header" not in data:
-            return
-        header = bcf.v3.data.Header()
-        if data["Header"].get("Files"):
-            for item in data["Header"]["Files"].get("File", []):
-                header_file = bcf.v3.data.HeaderFile()
-                optional_keys = {
-                    "filename": "Filename",
-                    "date": "Date",
-                    "reference": "Reference",
-                    "ifc_project": "@IfcProject",
-                    "ifc_spatial_structure_element": "@IfcSpatialStructureElement",
-                    "is_external": "@IsExternal",
-                }
-                for key, value in optional_keys.items():
-                    if value in item:
-                        setattr(header_file, key, item[value])
-                header.files.append(header_file)
-            self.topics[guid].header = header
-            return header
-
-    def get_topic(self, guid):
-        if guid in self.topics:
-            return self.topics[guid]
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        topic = bcf.v3.data.Topic()
-        self.topics[guid] = topic
-
-        mandatory_keys = {
-            "guid": "@Guid",
-            "title": "Title",
-            "creation_date": "CreationDate",
-            "creation_author": "CreationAuthor",
-            "topic_status": "@TopicStatus",
-            "topic_type": "@TopicType",
-        }
-        for key, value in mandatory_keys.items():
-            setattr(topic, key, data["Topic"][value])
-
-        optional_keys = {
-            "priority": "Priority",
-            "index": "Index",
-            "modified_date": "ModifiedDate",
-            "modified_author": "ModifiedAuthor",
-            "due_date": "DueDate",
-            "assigned_to": "AssignedTo",
-            "stage": "Stage",
-            "description": "Description",
-            "server_assigned_id": "@ServerAssignedId",
-        }
-        for key, value in optional_keys.items():
-            if value in data["Topic"]:
-                setattr(topic, key, data["Topic"][value])
-
-        if data["Topic"].get("ReferenceLinks"):
-            topic.reference_links.extend(data["Topic"]["ReferenceLinks"].get("ReferenceLink", []))
-
-        if data["Topic"].get("Labels"):
-            topic.labels.extend(data["Topic"]["Labels"].get("Label", []))
-
-        if "BimSnippet" in data["Topic"]:
-            bim_snippet = bcf.v3.data.BimSnippet()
-            keys = {
-                "snippet_type": "@SnippetType",
-                "is_external": "@IsExternal",
-                "reference": "Reference",
-                "reference_schema": "ReferenceSchema",
-            }
-            for key, value in keys.items():
-                if value in data["Topic"]["BimSnippet"]:
-                    setattr(bim_snippet, key, data["Topic"]["BimSnippet"][value])
-            topic.bim_snippet = bim_snippet
-
-        if data["Topic"].get("DocumentReferences"):
-            for item in data["Topic"]["DocumentReferences"].get("DocumentReference", []):
-                document_reference = bcf.v3.data.DocumentReference()
-                keys = {
-                    "document_guid": "DocumentGuid",
-                    "url": "Url",
-                    "guid": "@Guid",
-                    "description": "Description",
-                }
-                for key, value in keys.items():
-                    if value in item:
-                        setattr(document_reference, key, item[value])
-                topic.document_references.append(document_reference)
-
-        if data["Topic"].get("RelatedTopics"):
-            for item in data["Topic"]["RelatedTopics"].get("RelatedTopic", []):
-                related_topic = bcf.v3.data.RelatedTopic()
-                related_topic.guid = item["@Guid"]
-                topic.related_topics.append(related_topic)
-        return topic
-
-    def add_topic(self, topic=None):
-        if topic is None:
-            topic = bcf.v3.data.Topic()
-        if not topic.guid:
-            topic.guid = str(uuid.uuid4())
-        if not topic.title:
-            topic.title = "New Topic"
-        os.mkdir(os.path.join(self.filepath, topic.guid))
-        self.edit_topic(topic)
-        return topic
-
-    def edit_topic(self, topic):
-        if not topic.creation_date:
-            topic.creation_date = datetime.utcnow().isoformat()
-            topic.creation_author = self.author
-        else:
-            topic.modified_date = datetime.utcnow().isoformat()
-            topic.modified_author = self.author
-
-        self.document = minidom.Document()
-        root = self._create_element(self.document, "Markup")
-        if topic.header:
-            self.write_header(topic.header, root)
-
-        topic_el = self._create_element(
-            root,
-            "Topic",
-            {
-                "Guid": topic.guid,
-                "ServerAssignedId": topic.server_assigned_id,
-                "TopicType": topic.topic_type,
-                "TopicStatus": topic.topic_status,
-            },
-        )
-        if topic.reference_links:
-            reference_Links_el = self._create_element(topic_el, "ReferenceLinks")
-            for reference_link in topic.reference_links:
-                self._create_element(reference_Links_el, "ReferenceLink", text=reference_link)
-
-        text_map = {
-            "Title": topic.title,
-            "Priority": topic.priority,
-            "Index": topic.index,
-        }
-        for key, value in text_map.items():
-            if value:
-                self._create_element(topic_el, key, text=value)
-        if topic.labels:
-            label_el = self._create_element(topic_el, "Labels")
-            for label in topic.labels:
-                self._create_element(label_el, "Label", text=label)
-
-        text_map = {
-            "CreationDate": topic.creation_date,
-            "CreationAuthor": topic.creation_author,
-            "ModifiedDate": topic.modified_date,
-            "ModifiedAuthor": topic.modified_author,
-            "DueDate": topic.due_date,
-            "AssignedTo": topic.assigned_to,
-            "Stage": topic.stage,
-            "Description": topic.description,
-        }
-        for key, value in text_map.items():
-            if value:
-                self._create_element(topic_el, key, text=value)
-
-        if topic.bim_snippet:
-            bim_snippet = self._create_element(
-                topic_el,
-                "BimSnippet",
-                {
-                    "SnippetType": topic.bim_snippet.snippet_type,
-                    "IsExternal": topic.bim_snippet.is_external,
-                },
-            )
-            self._create_element(bim_snippet, "Reference", text=topic.bim_snippet.reference)
-            self._create_element(
-                bim_snippet,
-                "ReferenceSchema",
-                text=topic.bim_snippet.reference_schema,
-            )
-        if topic.document_references:
-            reference_el = self._create_element(topic_el, "DocumentReferences")
-            self.write_document_references(topic.document_references, reference_el)
-        if topic.related_topics:
-            related_topic_el = self._create_element(topic_el, "RelatedTopics")
-            for related_topic in topic.related_topics:
-                self._create_element(related_topic_el, "RelatedTopic", {"Guid": related_topic.guid})
-        if topic.comments:
-            comment_el = self._create_element(topic_el, "Comments")
-            self.write_comments(topic.comments, comment_el)
-        if topic.viewpoints:
-            viewpoint_el = self._create_element(topic_el, "Viewpoints")
-            self.write_viewpoints(topic.viewpoints, viewpoint_el, topic)
-        with open(os.path.join(self.filepath, topic.guid, "markup.bcf"), "wb") as f:
-            f.write(self.document.toprettyxml(encoding="utf-8"))
-
-    def write_document_references(self, references, root):
-        for reference in references:
-            document_reference_el = self._create_element(root, "DocumentReference", {"Guid": reference.guid})
-            if reference.document_guid:
-                self._create_element(document_reference_el, "DocumentGuid", text=reference.document_guid)
-            elif reference.url:
-                self._create_element(document_reference_el, "Url", text=reference.url)
-            if reference.description:
-                self._create_element(document_reference_el, "Description", text=reference.description)
-
-    def write_header(self, header, root):
-        if not header or not header.files:
-            return
-        header_el = self._create_element(root, "Header")
-        files_el = self._create_element(header_el, "Files")
-        for f in header.files:
-            file_el = self._create_element(
-                files_el,
-                "File",
-                {
-                    "IfcProject": f.ifc_project,
-                    "IfcSpatialStructureElement": f.ifc_spatial_structure_element,
-                    "IsExternal": f.is_external,
-                },
-            )
-            if f.filename:
-                self._create_element(file_el, "Filename", text=f.filename)
-            if f.date:
-                self._create_element(file_el, "Date", text=f.date)
-            if f.reference:
-                self._create_element(file_el, "Reference", text=f.reference)
-
-    def write_comments(self, comments, root):
-        for comment in comments.values():
-            comment_el = self._create_element(root, "Comment", {"Guid": comment.guid})
-            text_map = {
-                "Date": comment.date,
-                "Author": comment.author,
-                "Comment": comment.comment,
-                "ModifiedDate": comment.modified_date,
-                "ModifiedAuthor": comment.modified_author,
-            }
-            for key, value in text_map.items():
-                if value:
-                    self._create_element(comment_el, key, text=value)
-            if comment.viewpoint:
-                self._create_element(comment_el, "Viewpoint", {"Guid": comment.viewpoint.guid})
-
-    def add_comment(self, topic, comment=None):
-        if comment is None:
-            comment = bcf.v3.data.Comment()
-        if not comment.guid:
-            comment.guid = str(uuid.uuid4())
-        if not comment.comment:
-            comment.comment = "'Free software' is a matter of liberty, not price. To understand the concept, you should think of 'free' as in 'free speech,' not as in 'free beer'."
-        topic.comments[comment.guid] = comment
-        self.edit_comment(comment, topic)
-
-    def edit_comment(self, comment, topic):
-        if not comment.date:
-            comment.date = datetime.utcnow().isoformat()
-            comment.author = self.author
-        else:
-            comment.modified_date = datetime.utcnow().isoformat()
-            comment.modified_author = self.author
-        self.edit_topic(topic)
-
-    def delete_comment(self, guid, topic):
-        if guid in topic.comments:
-            del topic.comments[guid]
-        self.edit_topic(topic)
-
-    def delete_topic(self, guid):
-        if guid in self.topics:
-            del self.topics[guid]
-        shutil.rmtree(os.path.join(self.filepath, guid))
-
-    def write_viewpoints(self, viewpoints, root, topic):
-        for viewpoint in viewpoints.values():
-            viewpoint_el = self._create_element(root, "ViewPoint", {"Guid": viewpoint.guid})
-            text_map = {
-                "Viewpoint": viewpoint.viewpoint,
-                "Snapshot": viewpoint.snapshot,
-                "Index": viewpoint.index,
-            }
-            for key, value in text_map.items():
-                if value:
-                    self._create_element(viewpoint_el, key, text=value)
-            self.write_viewpoint(viewpoint, topic)
-
-    def write_viewpoint(self, viewpoint, topic):
-        document = minidom.Document()
-        root = self._create_element(document, "VisualizationInfo", {"Guid": viewpoint.guid})
-        self.write_viewpoint_components(viewpoint, root)
-        self.write_viewpoint_orthogonal_camera(viewpoint, root)
-        self.write_viewpoint_perspective_camera(viewpoint, root)
-        self.write_viewpoint_lines(viewpoint, root)
-        self.write_viewpoint_clipping_planes(viewpoint, root)
-        self.write_viewpoint_bitmaps(viewpoint, root)
-        with open(os.path.join(self.filepath, topic.guid, viewpoint.viewpoint), "wb") as f:
-            f.write(document.toprettyxml(encoding="utf-8"))
-
-    def write_viewpoint_components(self, viewpoint, parent):
-        if not viewpoint.components:
-            return
-        components_el = self._create_element(parent, "Components")
-        if viewpoint.components.selection:
-            selection_el = self._create_element(components_el, "Selection")
-            for selection in viewpoint.components.selection:
-                self.write_component(selection, selection_el)
-        if viewpoint.components.visibility:
-            visibility = self._create_element(
-                components_el,
-                "Visibility",
-                {"DefaultVisibility": viewpoint.components.visibility.default_visibility},
-            )
-            if viewpoint.components.visibility.view_setup_hints:
-                view_setup_hints = self._create_element(
-                    visibility,
-                    "ViewSetupHints",
-                    {
-                        "SpacesVisible": viewpoint.components.visibility.view_setup_hints.spaces_visible,
-                        "SpaceBoundariesVisible": viewpoint.components.visibility.view_setup_hints.space_boundaries_visible,
-                        "OpeningsVisible": viewpoint.components.visibility.view_setup_hints.openings_visible,
-                    },
-                )
-            if viewpoint.components.visibility.exceptions:
-                exceptions_el = self._create_element(visibility, "Exceptions")
-                for exception in viewpoint.components.visibility.exceptions:
-                    self.write_component(exception, exceptions_el)
-        if viewpoint.components.coloring:
-            coloring_el = self._create_element(components_el, "Coloring")
-            for color in viewpoint.components.coloring:
-                color_el = self._create_element(coloring_el, "Color", {"Color": color.color})
-                component_el = self._create_element(color_el, "Components")
-                for component in color.components:
-                    self.write_component(component, component_el)
-
-    def write_viewpoint_orthogonal_camera(self, viewpoint, parent):
-        if not viewpoint.orthogonal_camera:
-            return
-        camera = viewpoint.orthogonal_camera
-        camera_el = self._create_element(parent, "OrthogonalCamera")
-        camera_view_point = self._create_element(camera_el, "CameraViewPoint")
-        self.write_vector(camera_view_point, camera.camera_view_point)
-        camera_direction = self._create_element(camera_el, "CameraDirection")
-        self.write_vector(camera_direction, camera.camera_direction)
-        camera_up_vector = self._create_element(camera_el, "CameraUpVector")
-        self.write_vector(camera_up_vector, camera.camera_up_vector)
-        self._create_element(camera_el, "ViewToWorldScale", text=camera.view_to_world_scale)
-        self._create_element(camera_el, "AspectRatio", text=camera.aspect_ratio)
-
-    def write_viewpoint_perspective_camera(self, viewpoint, parent):
-        if not viewpoint.perspective_camera:
-            return
-        camera = viewpoint.perspective_camera
-        camera_el = self._create_element(parent, "PerspectiveCamera")
-        camera_view_point = self._create_element(camera_el, "CameraViewPoint")
-        self.write_vector(camera_view_point, camera.camera_view_point)
-        camera_direction = self._create_element(camera_el, "CameraDirection")
-        self.write_vector(camera_direction, camera.camera_direction)
-        camera_up_vector = self._create_element(camera_el, "CameraUpVector")
-        self.write_vector(camera_up_vector, camera.camera_up_vector)
-        self._create_element(camera_el, "FieldOfView", text=camera.field_of_view)
-        self._create_element(camera_el, "AspectRatio", text=camera.aspect_ratio)
-
-    def write_viewpoint_lines(self, viewpoint, parent):
-        if not viewpoint.lines:
-            return
-        lines_el = self._create_element(parent, "Lines")
-        for line in viewpoint.lines:
-            line_el = self._create_element(lines_el, "Line")
-            start_point_el = self._create_element(line_el, "StartPoint")
-            self.write_vector(start_point_el, line.start_point)
-            end_point_el = self._create_element(line_el, "EndPoint")
-            self.write_vector(end_point_el, line.end_point)
-
-    def write_viewpoint_clipping_planes(self, viewpoint, parent):
-        if not viewpoint.clipping_planes:
-            return
-        planes_el = self._create_element(parent, "ClippingPlanes")
-        for plane in viewpoint.clipping_planes:
-            plane_el = self._create_element(planes_el, "ClippingPlane")
-            location_el = self._create_element(plane_el, "Location")
-            self.write_vector(location_el, plane.location)
-            direction_el = self._create_element(plane_el, "Direction")
-            self.write_vector(direction_el, plane.direction)
-
-    def write_viewpoint_bitmaps(self, viewpoint, parent):
-        if not viewpoint.bitmaps:
-            return
-        bitmaps_el = self._create_element(parent, "Bitmaps")
-        for bitmap in viewpoint.bitmaps:
-            bitmap_el = self._create_element(bitmaps_el, "Bitmap")
-
-            text_map = {"Format": bitmap.bitmap_format, "Reference": bitmap.reference}
-            for key, value in text_map.items():
-                self._create_element(bitmap_el, key, text=value)
-
-            location_el = self._create_element(bitmap_el, "Location")
-            self.write_vector(location_el, bitmap.location)
-            normal_el = self._create_element(bitmap_el, "Normal")
-            self.write_vector(normal_el, bitmap.normal)
-            up_el = self._create_element(bitmap_el, "Up")
-            self.write_vector(up_el, bitmap.up)
-
-            self._create_element(bitmap_el, "Height", text=bitmap.height)
-
-    def write_vector(self, parent, from_obj):
-        self._create_element(parent, "X", text=from_obj.x)
-        self._create_element(parent, "Y", text=from_obj.y)
-        self._create_element(parent, "Z", text=from_obj.z)
-
-    def write_component(self, data, parent):
-        component_el = self._create_element(parent, "Component", {"IfcGuid": data.ifc_guid})
-        text_map = {
-            "OriginatingSystem": data.originating_system,
-            "AuthoringToolId": data.authoring_tool_id,
-        }
-        for key, value in text_map.items():
-            if value:
-                self._create_element(component_el, key, text=value)
-
-    def add_viewpoint(self, topic, viewpoint=None):
-        if not viewpoint:
-            viewpoint = bcf.v3.data.Viewpoint()
-        if not viewpoint.guid:
-            viewpoint.guid = str(uuid.uuid4())
-        if not viewpoint.viewpoint:
-            viewpoint.viewpoint = f"{viewpoint.guid}.bcfv"
-        if viewpoint.snapshot:
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            filepath = os.path.join(topic_filepath, viewpoint.snapshot)
-            if not os.path.exists(filepath):
-                filename = viewpoint.guid + os.path.splitext(viewpoint.snapshot)[-1]
-                copyfile(viewpoint.snapshot, os.path.join(topic_filepath, filename))
-                viewpoint.snapshot = filename
-        topic.viewpoints[viewpoint.guid] = viewpoint
-        self.edit_topic(topic)
-
-    def delete_viewpoint(self, guid, topic):
-        if guid not in topic.viewpoints:
-            return
-        viewpoint = topic.viewpoints[guid]
-        if viewpoint.snapshot:
-            filepath = os.path.join(self.filepath, topic.guid, viewpoint.snapshot)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        if viewpoint.viewpoint:
-            filepath = os.path.join(self.filepath, topic.guid, viewpoint.viewpoint)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        for bitmap in viewpoint.bitmaps:
-            if not bitmap.reference:
-                continue
-            filepath = os.path.join(self.filepath, topic.guid, bitmap.reference)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        del topic.viewpoints[guid]
-        self.edit_topic(topic)
-
-    def delete_file(self, topic, index):
-        if not topic.header:
-            return
-        f = topic.header.files.pop(index)
-        filepath = os.path.join(self.filepath, topic.guid, f.reference)
-        if not f.is_external and os.path.exists(filepath):
-            os.remove(filepath)
-        self.edit_topic(topic)
-
-    def delete_bim_snippet(self, topic):
-        if not topic.bim_snippet:
-            return
-        if topic.bim_snippet.reference and not topic.bim_snippet.is_external:
-            filepath = os.path.join(self.filepath, topic.guid, topic.bim_snippet.reference)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        topic.bim_snippet = None
-        self.edit_topic(topic)
-
-    def delete_document_reference(self, topic, index):
-        document_reference = topic.document_references[index]
-        if document_reference.referenced_document and not document_reference.is_external:
-            filepath = os.path.join(self.filepath, topic.guid, document_reference.referenced_document)
-            if os.path.exists(filepath):
-                os.remove(filepath)
-        del topic.document_references[index]
-        self.edit_topic(topic)
-
-    def add_document_reference(self, topic, document_reference):
-        if os.path.exists(document_reference.referenced_document):
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            filename = os.path.basename(document_reference.referenced_document)
-            copyfile(
-                document_reference.referenced_document,
-                os.path.join(topic_filepath, filename),
-            )
-            document_reference.referenced_document = filename
-            document_reference.is_external = False
-        else:
-            document_reference.is_external = True
-        if not document_reference.guid:
-            document_reference.guid = str(uuid.uuid4())
-        topic.document_references.append(document_reference)
-        self.edit_topic(topic)
-
-    def add_bim_snippet(self, topic, bim_snippet):
-        if topic.bim_snippet:
-            self.delete_bim_snippet(topic)
-        if os.path.exists(bim_snippet.reference):
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            filename = os.path.basename(bim_snippet.reference)
-            copyfile(bim_snippet.reference, os.path.join(topic_filepath, filename))
-            bim_snippet.reference = filename
-            bim_snippet.is_external = False
-        else:
-            bim_snippet.is_external = True
-        topic.bim_snippet = bim_snippet
-        self.edit_topic(topic)
-
-    def add_file(self, topic, header_file):
-        if os.path.exists(header_file.reference):
-            topic_filepath = os.path.join(self.filepath, topic.guid)
-            header_file.filename = os.path.basename(header_file.reference)
-            copyfile(
-                header_file.reference,
-                os.path.join(topic_filepath, header_file.filename),
-            )
-            header_file.reference = header_file.filename
-            header_file.is_external = False
-        header_file.date = datetime.utcnow().isoformat()
-        if not topic.header:
-            topic.header = bcf.v3.data.Header()
-        topic.header.files.append(header_file)
-        self.edit_topic(topic)
-
-    def get_comments(self, guid):
-        comments = {}
-        if "Comments" not in data["Topics"]:
-            return comments
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        for item in data["Topic"]["Comments"].get("Comment", []):
-            comment = bcf.v3.data.Comment()
-            mandatory_keys = {
-                "guid": "@Guid",
-                "date": "Date",
-                "author": "Author",
-            }
-            for key, value in mandatory_keys.items():
-                setattr(comment, key, item[value])
-            optional_keys = {
-                "comment": "Comment",
-                "modified_date": "ModifiedDate",
-                "modified_author": "ModifiedAuthor",
-            }
-            for key, value in optional_keys.items():
-                if value in item:
-                    setattr(comment, key, item[value])
-            if "Viewpoint" in item:
-                viewpoint = bcf.v3.data.Viewpoint()
-                viewpoint.guid = item["Viewpoint"]["@Guid"]
-                comment.viewpoint = viewpoint
-            comments[comment.guid] = comment
-        self.topics[guid].comments = comments
-        return comments
-
-    def get_viewpoints(self, guid):
-        viewpoints = {}
-        if "Viewpoints" not in data["Topic"]:
-            return viewpoints
-        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        for item in data["Topic"]["Viewpoints"]:
-            viewpoint = self.get_viewpoint(item, guid)
-            viewpoints[viewpoint.guid] = viewpoint
-        self.topics[guid].viewpoints = viewpoints
-        return viewpoints
-
-    def get_viewpoint(self, data, topic_guid):
-        viewpoint = bcf.v3.data.Viewpoint()
-        viewpoint.guid = data["@Guid"]
-        optional_keys = {
-            "viewpoint": "Viewpoint",
-            "snapshot": "Snapshot",
-            "index": "Index",
-        }
-        for key, value in optional_keys.items():
-            if value in data:
-                setattr(viewpoint, key, data[value])
-        visinfo = self._read_xml(os.path.join(topic_guid, viewpoint.viewpoint), "visinfo.xsd")
-        viewpoint.components = self.get_viewpoint_components(visinfo)
-        viewpoint.orthogonal_camera = self.get_viewpoint_orthogonal_camera(visinfo)
-        viewpoint.perspective_camera = self.get_viewpoint_perspective_camera(visinfo)
-        viewpoint.lines = self.get_viewpoint_lines(visinfo)
-        viewpoint.clipping_planes = self.get_viewpoint_clipping_planes(visinfo)
-        viewpoint.bitmaps = self.get_viewpoint_bitmaps(visinfo)
-        return viewpoint
-
-    def get_viewpoint_components(self, visinfo):
-        if "Components" not in visinfo:
-            return None
-        components = bcf.v3.data.Components()
-        data = visinfo["Components"]
-        if "Selection" in data and "Component" in data["Selection"]:
-            for item in data["Selection"].get("Component", []):
-                components.selection.append(self.get_component(item))
-        if "Visibility" in data:
-            component_visibility = bcf.v3.data.ComponentVisibility()
-            if "@DefaultVisibility" in data["Visibility"]:
-                component_visibility.default_visibility = data["Visibility"]["@DefaultVisibility"]
-            if "Exceptions" in data["Visibility"] and "Component" in data["Visibility"]["Exceptions"]:
-                for item in data["Visibility"]["Exceptions"]["Component"]:
-                    component_visibility.exceptions.append(self.get_component(item))
-            if "ViewSetupHints" in data["Visibility"]:
-                view_setup_hints = bcf.v3.data.ViewSetupHints()
-                optional_keys = {
-                    "spaces_visible": "@SpacesVisible",
-                    "space_boundaries_visible": "@SpaceBoundariesVisible",
-                    "openings_visible": "@OpeningsVisible",
-                }
-                for key, value in optional_keys.items():
-                    if value in data["Visibility"]["ViewSetupHints"]:
-                        setattr(view_setup_hints, key, data["Visibility"]["ViewSetupHints"][value])
-                component_visibility.view_setup_hints = view_setup_hints
-            components.visibility = component_visibility
-        if "Coloring" in data and "Color" in data["Coloring"]:
-            for item in data["Coloring"]["Color"]:
-                color = bcf.v3.data.Color()
-                color.color = item["@Color"]
-                for item2 in item["Components"]["Component"]:
-                    color.components.append(self.get_component(item2))
-                components.coloring.append(color)
-        return components
-
-    def get_viewpoint_orthogonal_camera(self, visinfo):
-        if "OrthogonalCamera" not in visinfo:
-            return None
-        camera = bcf.v3.data.OrthogonalCamera()
-        data = visinfo["OrthogonalCamera"]
-        self.set_vector(camera.camera_view_point, data["CameraViewPoint"])
-        self.set_vector(camera.camera_direction, data["CameraDirection"])
-        self.set_vector(camera.camera_up_vector, data["CameraUpVector"])
-        camera.view_to_world_scale = data["ViewToWorldScale"]
-        camera.aspect_ratio = data["AspectRatio"]
-        return camera
-
-    def get_viewpoint_perspective_camera(self, visinfo):
-        if "PerspectiveCamera" not in visinfo:
-            return None
-        camera = bcf.v3.data.PerspectiveCamera()
-        data = visinfo["PerspectiveCamera"]
-        self.set_vector(camera.camera_view_point, data["CameraViewPoint"])
-        self.set_vector(camera.camera_direction, data["CameraDirection"])
-        self.set_vector(camera.camera_up_vector, data["CameraUpVector"])
-        camera.field_of_view = data["FieldOfView"]
-        camera.aspect_ratio = data["AspectRatio"]
-        return camera
-
-    def get_viewpoint_lines(self, visinfo):
-        if "Lines" not in visinfo:
-            return []
-        lines = []
-        for item in visinfo["Lines"].get("Line", []):
-            line = bcf.v3.data.Line()
-            self.set_vector(line.start_point, item["StartPoint"])
-            self.set_vector(line.end_point, item["EndPoint"])
-            lines.append(line)
-        return lines
-
-    def get_viewpoint_clipping_planes(self, visinfo):
-        if "ClippingPlanes" not in visinfo:
-            return []
-        planes = []
-        for item in visinfo["ClippingPlanes"]["ClippingPlane"]:
-            plane = bcf.v3.data.ClippingPlane()
-            self.set_vector(plane.location, item["Location"])
-            self.set_vector(plane.direction, item["Direction"])
-            planes.append(plane)
-        return planes
-
-    def get_viewpoint_bitmaps(self, visinfo):
-        if "Bitmaps" not in visinfo:
-            return []
-        bitmaps = []
-        for item in visinfo["Bitmaps"].get("Bitmap"):
-            bitmap = bcf.v3.data.Bitmap()
-            bitmap.reference = item["Reference"]
-            bitmap.bitmap_format = item["Format"].upper()
-            self.set_vector(bitmap.location, item["Location"])
-            self.set_vector(bitmap.normal, item["Normal"])
-            self.set_vector(bitmap.up, item["Up"])
-            bitmap.height = item["Height"]
-            bitmaps.append(bitmap)
-        return bitmaps
-
-    def set_vector(self, to_obj, from_xml):
-        to_obj.x = from_xml["X"]
-        to_obj.y = from_xml["Y"]
-        to_obj.z = from_xml["Z"]
-
-    def get_component(self, data):
-        component = bcf.v3.data.Component()
-        optional_keys = {
-            "originating_system": "OriginatingSystem",
-            "authoring_tool_id": "AuthoringToolId",
-            "ifc_guid": "@IfcGuid",
-        }
-        for key, value in optional_keys.items():
-            if value in data:
-                setattr(component, key, data[value])
-        return component
-
-    def close_project(self):
-        shutil.rmtree(self.filepath)
-
-    def _read_xml(self, filename, xsd):
-        schema = XMLSchema(os.path.join(cwd, "xsd", xsd))
-        filepath = os.path.join(self.filepath, filename)
-        (data, errors) = schema.to_dict(filepath, validation="lax")
-        for error in errors:
-            self.logger.error(error)
-        return data
-
-    def _create_element(self, parent, name, attributes={}, text=None):
-        element = self.document.createElement(name)
-        for key, value in attributes.items():
-            if isinstance(value, bool):
-                element.setAttribute(key, str(value).lower())
-            elif value:
-                element.setAttribute(key, value)
-        if text is not None:
-            text = self.document.createTextNode(str(text))
-            element.appendChild(text)
-        parent.appendChild(element)
-        return element
-
-    def __del__(self):
-        self.close_project()
@@ -1,181 +0,0 @@
-class Project:
-    def __init__(self):
-        self.project_id = ""
-        self.name = ""
-
-
-class BimSnippet:
-    def __init__(self):
-        self.snippet_type = None
-        self.is_external = False
-        self.reference = None
-        self.reference_schema = None
-
-
-class DocumentReference:
-    def __init__(self):
-        self.description = None
-        self.document_guid = None
-        self.url = None
-        self.guid = None
-
-
-class RelatedTopic:
-    def __init__(self):
-        self.guid = None
-
-
-class HeaderFile:
-    def __init__(self):
-        self.file_name = ""
-        self.date = None
-        self.reference = ""
-        self.ifc_project = None
-        self.ifc_spatial_structure_element = None
-        self.is_external = True
-
-
-class Header:
-    def __init__(self):
-        self.files = []
-
-
-class Topic:
-    def __init__(self):
-        self.reference_links = []
-        self.title = ""
-        self.priority = None
-        self.index = None  # Deprecated, stored, but ignored
-        self.labels = []
-        self.creation_date = None
-        self.creation_author = None
-        self.modified_date = None
-        self.modified_author = None
-        self.due_date = None
-        self.assigned_to = None
-        self.stage = None
-        self.description = None
-        self.bim_snippet = None
-        self.document_references = []
-        self.related_topics = []
-        self.topic_status = None
-        self.topic_type = None
-        self.guid = None
-
-        self.header = None
-        self.comments = {}
-        self.viewpoints = {}
-        self.server_assigned_id = ""
-
-
-class Comment:
-    def __init__(self):
-        self.guid = None
-        self.date = None
-        self.author = ""
-        self.comment = ""
-        self.viewpoint = None
-        self.modified_date = None
-        self.modified_author = ""
-
-
-class ViewSetupHints:
-    def __init__(self):
-        self.spaces_visible = False
-        self.space_boundaries_visible = False
-        self.openings_visible = False
-
-
-class Component:
-    def __init__(self):
-        self.originating_system = None
-        self.authoring_tool_id = None
-        self.ifc_guid = None
-
-
-class ComponentVisibility:
-    def __init__(self):
-        self.exceptions = []
-        self.default_visibility = False
-        self.view_setup_hints = None
-
-
-class Color:
-    def __init__(self):
-        self.color = None
-        self.components = []
-
-
-class Components:
-    def __init__(self):
-
-        self.selection = []
-        self.visibility = None
-        self.coloring = []
-
-
-class Point:
-    def __init__(self):
-        self.x = 0
-        self.y = 0
-        self.z = 0
-
-
-class Direction(Point):
-    pass
-
-
-class OrthogonalCamera:
-    def __init__(self):
-        self.camera_view_point = Point()
-        self.camera_direction = Direction()
-        self.camera_up_vector = Direction()
-        self.view_to_world_scale = 1.0
-        self.aspect_ratio = 1.0
-
-
-class PerspectiveCamera:
-    def __init__(self):
-        self.camera_view_point = Point()
-        self.camera_direction = Direction()
-        self.camera_up_vector = Direction()
-        self.field_of_view = 60.0
-        self.aspect_ratio = 1.0
-
-
-class Line:
-    def __init__(self):
-        self.start_point = Point()
-        self.end_point = Point()
-
-
-class ClippingPlane:
-    def __init__(self):
-        self.location = Point()
-        self.direction = Direction()
-
-
-class Bitmap:
-    def __init__(self):
-        self.reference = ""  # Only in BCF-XML
-        self.bitmap_data = None  # Only in BCF-API
-        self.bitmap_format = "PNG"  # Enum of png or jpg
-        self.location = Point()
-        self.normal = Direction()
-        self.up = Direction()
-        self.height = 1.0
-
-
-class Viewpoint:
-    def __init__(self):
-        self.guid = None
-        self.viewpoint = None
-        self.snapshot = None
-        self.index = None
-
-        self.components = None  # It's not a list, despite the plural name
-        self.orthogonal_camera = None
-        self.perspective_camera = None
-        self.lines = []
-        self.clipping_planes = []
-        self.bitmaps = []
@@ -0,0 +1,7 @@
+name: bcf-client
+channels:
+  - conda-forge
+dependencies:
+  - ifcopenshell
+  - xsdata
+  - numpy
@@ -0,0 +1,126 @@
+[build-system]
+requires = [
+    "setuptools>=61",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bcf-client"
+# author = "IfcOpenShell"
+description = "BCF-XML file handler."
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["IFC", "BCF", "BIM", "eingineering"]
+dependencies = [
+    "xsdata",
+    "numpy",
+]
+version = "0.0.1"
+classifiers = [
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Source = "https://github.com/IfcOpenShell/IfcOpenShell"
+Issues = "https://github.com/IfcOpenShell/IfcOpenShell/issues"
+
+[tool.black]
+line-length = 120
+extend-exclude = "model"
+
+[tool.isort]
+profile = "black"
+extend_skip_glob = ["src/bcf/*/model/*"]
+
+[tool.coverage.paths]
+source = ["src"]
+
+[tool.coverage.run]
+branch = true
+source = ["bcf"]
+omit = ["*/model/*"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 65
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING",
+    "if __name__ == .__main__.:",
+    "Protocol",
+]
+
+[tool.tox]
+legacy_tox_ini = """
+[tox]
+envlist = py310
+isolated_build = true
+skip_missing_interpreters = true
+requires = tox-conda
+
+[testenv]
+conda_deps =
+    pytest
+    pytest-cov
+    coverage
+conda_channels =
+    conda-forge
+conda_env = environment.yml
+commands = pytest --cov --cov-report=term tests
+"""
+
+[tool.mypy]
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+#no_implicit_reexport = true
+show_column_numbers = true
+show_error_codes = true
+show_error_context = true
+strict_equality = true
+strict_optional = true
+warn_redundant_casts = true
+#warn_return_any = true
+warn_unreachable = true
+warn_unused_configs = true
+warn_unused_ignores = true
+exclude= "src/bcf/v(2|3)/model"
+plugins = "numpy.typing.mypy_plugin"
+
+[[tool.mypy.overrides]]
+module = "tests"
+disallow_untyped_decorators = false
+disallow_untyped_defs = false
+
+[[tool.mypy.overrides]]
+module = [
+    "pytest",
+    "pytest_mock",
+    "ifcopenshell",
+    "ifcopenshell.*",
+]
+ignore_missing_imports = true
+
+[tool.pylint.main]
+ignore = ["model"]
+ignored-modules = ["bcf.v2.model", "bcf.v3.model", "xsdata"]
+jobs = 0
+disable="all"
+enable="E" # B,B9,BLK,C,D,E,F,I,N,S,W
+
+[tool.pylint.design]
+max-args = 10
+max-attributes = 10
+
+[tool.pylint.format]
+expected-line-ending-format = "LF"
+max-line-length = 120
@@ -0,0 +1,7 @@
+black
+mypy
+pylint
+isort
+xsdata
+tox
+tox-conda
@@ -1 +0,0 @@
-xmlschema
@@ -0,0 +1,3 @@
+from setuptools import setup
+
+setup()
@@ -0,0 +1,17 @@
+# BCF - BCF Python library
+# Copyright (C) 2021 Prabhat Singh <singh01prabhat@gmail.com>
+#
+# This file is part of BCF.
+#
+# BCF is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BCF is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with BCF.  If not, see <http://www.gnu.org/licenses/>.
@@ -0,0 +1,69 @@
+"""
+BCF - BCF Python library
+Copyright (C) 2021 Prabhat Singh <singh01prabhat@gmail.com>
+Copyright (C) 2022 Andrea Ghensi <andrea.ghensi@gmail.com>
+
+This file is part of BCF.
+
+BCF is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+BCF is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with BCF.  If not, see <http://www.gnu.org/licenses/>.
+"""
+import zipfile
+from pathlib import Path
+from typing import Optional, Union
+
+from bcf.v2.bcfxml import BcfXml as BcfXml2
+from bcf.v3.bcfxml import BcfXml as BcfXml3
+from bcf.v3.model import Version
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+
+def load(
+    filepath: Path, xml_handler: Optional[AbstractXmlParserSerializer] = None
+) -> Optional[Union[BcfXml2, BcfXml3]]:
+    """
+    Load a BCF file.
+
+    Args:
+        filepath: The path to the BCF file.
+
+    Returns:
+        The loaded BCF file.
+
+    Raises:
+        ValueError: If the BCF version is not supported.
+    """
+    xml_handler = xml_handler or XmlParserSerializer()
+    version_id = _get_version(filepath, xml_handler)
+    if version_id in {"2.1", "2.0"}:
+        return BcfXml2.load(filepath, xml_handler)
+    if version_id == "3.0":
+        return BcfXml3.load(filepath, xml_handler)
+    raise ValueError(f"Version {version_id} not supported.")
+
+
+def _get_version(filepath: Union[str, Path], xml_handler: Optional[AbstractXmlParserSerializer] = None) -> str:
+    """
+    Returns the version of the BCF file.
+
+    Args:
+        filepath: The path to the BCF file.
+        xml_handler: The XML handler. If none is given, XmlParserSerializer is used.
+
+    Returns:
+        The version of the BCF file.
+    """
+    xml_handler = xml_handler or XmlParserSerializer()
+    with zipfile.ZipFile(filepath) as bcf_zip:
+        version = xml_handler.parse(bcf_zip.read("bcf.version"), Version)
+        return version.version_id
@@ -0,0 +1,44 @@
+import numpy as np
+from numpy.typing import NDArray
+
+
+def calc_camera_vectors(
+    elem_placement: NDArray[np.float_],
+) -> tuple[NDArray[np.float_], NDArray[np.float_], NDArray[np.float_]]:
+    """
+    Calculate the vectors of a camera pointing to an element.
+
+    Args:
+        elem_placement: Placement matrix of an element.
+
+    Returns:
+        Camera position, direction and up vectors
+    """
+    target_position = elem_placement[:3, 3]
+    camera_position = target_position + np.array((5, 5, 5))
+    camera_direction = unit_vector(camera_position - target_position)
+    camera_right = unit_vector(np.cross(np.array([0.0, 0.0, 1.0]), camera_direction))
+    camera_up = unit_vector(np.cross(camera_direction, camera_right))
+    rotation_transform = np.eye(4)
+    rotation_transform[0, :3] = camera_right
+    rotation_transform[1, :3] = camera_up
+    rotation_transform[2, :3] = camera_direction
+    translation_transform = np.eye(4)
+    translation_transform[:3, -1] = -camera_position
+    look_at_transform = np.matmul(rotation_transform, translation_transform)
+    mat = np.linalg.inv(look_at_transform)
+    return camera_position, -mat[:3, 2], mat[:3, 1]
+
+
+def unit_vector(v: NDArray[np.float_]) -> NDArray[np.float_]:
+    """
+    Return the unit vector of a vector.
+
+    Args:
+        v: vector
+
+    Returns:
+        unit vector.
+    """
+    norm = np.linalg.norm(v)
+    return v if norm == 0 else v / norm
@@ -0,0 +1,55 @@
+"""
+In Memory Zip File management, taken from ruamel.std.zipfile
+
+Copyright (c) 2017-2020 Anthon van der Neut, Ruamel bvba
+
+original idea from https://stackoverflow.com/a/19722365/1307905
+"""
+import zipfile
+from io import BytesIO
+from os import PathLike
+from pathlib import Path
+from typing import Any, Optional, Protocol
+
+
+class ZipFileInterface(Protocol):
+    def writestr(self, filename_in_zip: str | zipfile.ZipInfo, file_contents: bytes | str) -> None:
+        ...
+
+
+class InMemoryZipFile:
+    def __init__(
+        self, file_name: Optional[str | Path] = None, compression: int = zipfile.ZIP_DEFLATED, debug: int = 0
+    ) -> None:
+        # Create the in-memory file-like object
+        self._file_name: Optional[str | Path] = str(file_name) if hasattr(file_name, "_from_parts") else file_name
+        self.in_memory_data = BytesIO()
+        # Create the in-memory zipfile
+        self.in_memory_zip = zipfile.ZipFile(self.in_memory_data, "w", compression, False)
+        self.in_memory_zip.debug = debug
+
+    def writestr(self, filename_in_zip: str | zipfile.ZipInfo, file_contents: bytes | str) -> None:
+        """Appends a file with name filename_in_zip and contents of
+        file_contents to the in-memory zip."""
+        self.in_memory_zip.writestr(filename_in_zip, file_contents)
+
+    def write_to_file(self, filename: str | bytes | PathLike[str] | PathLike[bytes] | int) -> None:
+        """Writes the in-memory zip to a file."""
+        # Mark the files as having been created on Windows so that
+        # Unix permissions are not inferred as 0000
+        for zfile in self.in_memory_zip.filelist:
+            zfile.create_system = 0
+        self.in_memory_zip.close()
+        with open(filename, "wb") as f:
+            f.write(self.data)
+
+    @property
+    def data(self) -> bytes:
+        return self.in_memory_data.getvalue()
+
+    def __enter__(self) -> "InMemoryZipFile":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        if self._file_name:
+            self.write_to_file(self._file_name)
@@ -0,0 +1,17 @@
+# BCF - BCF Python library
+# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BCF.
+#
+# BCF is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BCF is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with BCF.  If not, see <http://www.gnu.org/licenses/>.
@@ -0,0 +1,273 @@
+"""BCF XML V2 handler."""
+import uuid
+import warnings
+import zipfile
+from pathlib import Path
+from typing import Any, Optional, TypeVar
+
+import bcf.v2.model as mdl
+from bcf.inmemory_zipfile import InMemoryZipFile, ZipFileInterface
+from bcf.v2.topic import TopicHandler
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+T = TypeVar("T")
+
+
+class BcfXml:
+    """BCF XML handler."""
+
+    def __init__(
+        self, filename: Optional[Path] = None, xml_handler: Optional[AbstractXmlParserSerializer] = None
+    ) -> None:
+        self._filename = filename
+        self._xml_handler = xml_handler or XmlParserSerializer()
+        self._version: Optional[mdl.Version] = None
+        self._project_info: Optional[mdl.ProjectExtension] = None
+        self._topics: dict[str, TopicHandler] = {}
+        self._extension_schema: Optional[bytes] = None
+        self._zip_file = self._load_zip_file()
+
+    def __enter__(self) -> "BcfXml":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._zip_file:
+            self._zip_file.close()
+
+    def _load_zip_file(self) -> Optional[zipfile.ZipFile]:
+        return zipfile.ZipFile(self._filename) if self._filename else None
+
+    @property
+    def version(self) -> mdl.Version:
+        """Bcf Version."""
+        if not self._version:
+            self._version = (
+                self._xml_handler.parse(self._zip_file.read("bcf.version"), mdl.Version)
+                if self._zip_file
+                else mdl.Version(version_id="3.0")
+            )
+        return self._version
+
+    @version.setter
+    def version(self, value: mdl.Version) -> None:
+        self._version = value
+
+    @property
+    def project_info(self) -> Optional[mdl.ProjectExtension]:
+        """BCF project information."""
+        if not self._project_info and self._zip_file and zipfile.Path(self._zip_file, "project.bcfp").exists():
+            self._project_info = self._xml_handler.parse(self._zip_file.read("project.bcfp"), mdl.ProjectExtension)
+        return self._project_info
+
+    @project_info.setter
+    def project_info(self, value: Optional[mdl.ProjectExtension]) -> None:
+        self._project_info = value
+
+    @property
+    def project(self) -> Optional[mdl.Project]:
+        """BCF project."""
+        return self.project_info.project if self.project_info else None
+
+    @property
+    def extension_schema(self) -> Optional[bytes]:
+        if not self._extension_schema and self._zip_file and self.project_info and self.project_info.extension_schema:
+            self._extension_schema = self._zip_file.read(self.project_info.extension_schema)
+        return self._extension_schema
+
+    @extension_schema.setter
+    def extension_schema(self, value: bytes) -> None:
+        self._extension_schema = value
+
+    @property
+    def topics(self) -> dict[str, TopicHandler]:
+        """BCF topics."""
+        if not self._topics and self._zip_file:
+            self._topics = self._load_topics(self._zip_file, self._xml_handler)
+        return self._topics
+
+    def _load_topics(
+        self, zip_file: zipfile.ZipFile, xml_handler: AbstractXmlParserSerializer
+    ) -> dict[str, TopicHandler]:
+        topics = {}
+        for topic_dir in zipfile.Path(zip_file).iterdir():
+            if not topic_dir.is_dir():
+                continue
+            markup_path = topic_dir.joinpath("markup.bcf")
+            if not markup_path.exists():
+                continue
+            topics[topic_dir.name] = TopicHandler(topic_dir, xml_handler)
+        return topics
+
+    @classmethod
+    def load(cls, filename: Path, xml_handler: Optional[AbstractXmlParserSerializer] = None) -> Optional["BcfXml"]:
+        """
+        Create a BcfXml object from a file.
+
+        Args:
+            filename: Path to the file.
+            xml_handler: XML parser and serializer.
+
+        Returns:
+            A BcfXml object with the file contents.
+
+        Raises:
+            ValueError: If the file name is null or empty
+        """
+        if not filename:
+            raise ValueError("filename is required")
+        xml_handler = xml_handler or XmlParserSerializer()
+        return cls(xml_handler=xml_handler, filename=filename)
+
+    @classmethod
+    def create_new(
+        cls,
+        project_name: Optional[str] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> "BcfXml":
+        """
+        Create a new BcfXml object.
+
+        Args:
+            project_name: The name of the project.
+            xml_handler: XML parser and serializer.
+
+        Returns:
+            A new BcfXml object.
+        """
+        instance = cls(xml_handler=xml_handler or XmlParserSerializer())
+        instance.project_info = mdl.ProjectExtension(
+            project=mdl.Project(name=project_name, project_id=str(uuid.uuid4())), extension_schema=""
+        )
+        return instance
+
+    def save(self, filename: Optional[Path] = None, keep_open: bool = False) -> None:
+        """Save the BCF file to the given filename."""
+        if not filename and not self._filename:
+            raise ValueError("No file name specified, cannot save BCF file.")
+        if filename:
+            self._filename = filename
+        with InMemoryZipFile(self._filename) as bcf_zip:
+            self._save_project(bcf_zip)
+            self._save_version(bcf_zip)
+            self._save_topics(bcf_zip)
+        if keep_open:
+            self._zip_file = self._load_zip_file()
+
+    def _save_project(self, destination_zip: ZipFileInterface) -> None:
+        self._smart_save_xml(destination_zip, self._project_info, "project.bcfp")
+        if self.extension_schema and self.project_info:
+            destination_zip.writestr(self.project_info.extension_schema, self.extension_schema)
+
+    def _save_version(self, destination_zip: ZipFileInterface) -> None:
+        if not self._version and self._zip_file:
+            destination_zip.writestr("bcf.version", self._zip_file.read("bcf.version"))
+        else:
+            self._save_xml(destination_zip, "bcf.version", self.version)
+
+    def _smart_save_xml(self, destination_zip: ZipFileInterface, item: Any, target: str) -> None:
+        if item:
+            self._save_xml(destination_zip, target, item)
+        elif self._zip_file and zipfile.Path(self._zip_file, target).exists():
+            destination_zip.writestr(target, self._zip_file.read(target))
+
+    def _save_xml(self, destination_zip: ZipFileInterface, inner_file: str, xml_obj: Any) -> None:
+        destination_zip.writestr(inner_file, self._xml_handler.serialize(xml_obj))
+
+    def _save_topics(self, destination_zip: ZipFileInterface) -> None:
+        for topic_handler in self.topics.values():
+            topic_handler.save(destination_zip)
+
+    def add_topic(
+        self, title: str, description: str, author: str, topic_type: str = "", topic_status: str = ""
+    ) -> TopicHandler:
+        """
+        Add a new topic to the BCF.
+
+        Args:
+            title: The title of the topic.
+            description: The description of the topic.
+            author: The author of the topic.
+            topic_type: The type of the topic.
+            topic_status: The status of the topic.
+
+        Returns:
+            The newly created topic wrapped inside a TopicHandler object.
+        """
+        topic_handler = TopicHandler.create_new(
+            title,
+            description,
+            author,
+            topic_type=topic_type,
+            topic_status=topic_status,
+            xml_handler=self._xml_handler,
+        )
+        self.topics[topic_handler.guid] = topic_handler
+        return topic_handler
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BcfXml):
+            raise TypeError("Equality needs a BcfXml object.")
+        return self.version == other.version and self.project_info == other.project_info
+
+    # region Deprecated methods
+    def new_project(self) -> "BcfXml":
+        """Deprecated method."""
+        warnings.warn("new_project is deprecated, use create_new instead.", DeprecationWarning)
+        return self.create_new()
+
+    def get_project(self, _filepath: Optional[str] = None) -> Optional[mdl.Project]:
+        """Deprecated method."""
+        warnings.warn("get_project is deprecated, use project_info.project instead.", DeprecationWarning)
+        return self.project
+
+    def edit_project(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_project is deprecated, there's no need to use it.", DeprecationWarning)
+
+    def save_project(self, filepath: Path) -> None:
+        """Deprecated method."""
+        warnings.warn("save_project is deprecated, use save instead.", DeprecationWarning)
+        self.save(filepath)
+
+    def get_version(self) -> Optional[str]:
+        warnings.warn("get_version is deprecated, use version.version_id instead.", DeprecationWarning)
+        return self.version.version_id
+
+    def edit_version(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_version is deprecated, there's no need to use it.", DeprecationWarning)
+
+    def get_topics(self) -> dict[str, TopicHandler]:
+        """Deprecated method."""
+        warnings.warn("get_topics is deprecated, use topics instead.", DeprecationWarning)
+        return self.topics
+
+    def get_topic(self, guid: str) -> TopicHandler:
+        """Return a topic by its GUID."""
+        warnings.warn("get_topic is deprecated, use topics[guid] instead", DeprecationWarning)
+        return self.topics[guid]
+
+    def get_header(self, guid: str) -> Optional[mdl.Header]:
+        """Return the header of a Topic by its GUID."""
+        return self.topics[guid].header
+
+    def edit_topic(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_topic is deprecated, there's no need to use it.", DeprecationWarning)
+
+    def add_comment(self, _topic: mdl.Topic, _comment: Optional[mdl.Comment] = None) -> None:
+        """Deprecated method."""
+        warnings.warn("add_comment is deprecated, use topics methods instead.", DeprecationWarning)
+
+    def edit_comment(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_comment is deprecated, there's no need to use it.", DeprecationWarning)
+
+    # TODO: deprecate other methods
+    # endregion
@@ -0,0 +1,70 @@
+from bcf.v2.model.markup import (
+    BimSnippet,
+    Comment,
+    CommentViewpoint,
+    Header,
+    HeaderFile,
+    Markup,
+    Topic,
+    TopicDocumentReference,
+    TopicRelatedTopic,
+    ViewPoint,
+)
+from bcf.v2.model.project import Project, ProjectExtension
+from bcf.v2.model.version import Version
+from bcf.v2.model.visinfo import (
+    BitmapFormat,
+    ClippingPlane,
+    Component,
+    ComponentColoring,
+    ComponentColoringColor,
+    Components,
+    ComponentSelection,
+    ComponentVisibility,
+    ComponentVisibilityExceptions,
+    Direction,
+    Line,
+    OrthogonalCamera,
+    PerspectiveCamera,
+    Point,
+    ViewSetupHints,
+    VisualizationInfo,
+    VisualizationInfoBitmap,
+    VisualizationInfoClippingPlanes,
+    VisualizationInfoLines,
+)
+
+__all__ = [
+    "BimSnippet",
+    "Comment",
+    "CommentViewpoint",
+    "Header",
+    "HeaderFile",
+    "Markup",
+    "Topic",
+    "TopicDocumentReference",
+    "TopicRelatedTopic",
+    "ViewPoint",
+    "Project",
+    "ProjectExtension",
+    "Version",
+    "BitmapFormat",
+    "ClippingPlane",
+    "Component",
+    "ComponentColoring",
+    "ComponentColoringColor",
+    "ComponentSelection",
+    "ComponentVisibility",
+    "ComponentVisibilityExceptions",
+    "Components",
+    "Direction",
+    "Line",
+    "OrthogonalCamera",
+    "PerspectiveCamera",
+    "Point",
+    "ViewSetupHints",
+    "VisualizationInfo",
+    "VisualizationInfoBitmap",
+    "VisualizationInfoClippingPlanes",
+    "VisualizationInfoLines",
+]
@@ -0,0 +1,461 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from xsdata.models.datatype import XmlDateTime
+
+
+@dataclass(slots=True, kw_only=True)
+class BimSnippet:
+    reference: str = field(
+        metadata={
+            "name": "Reference",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    reference_schema: str = field(
+        metadata={
+            "name": "ReferenceSchema",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    snippet_type: str = field(
+        metadata={
+            "name": "SnippetType",
+            "type": "Attribute",
+            "required": True,
+        }
+    )
+    is_external: bool = field(
+        default=False,
+        metadata={
+            "name": "isExternal",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class CommentViewpoint:
+    class Meta:
+        global_type = False
+
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class HeaderFile:
+    class Meta:
+        global_type = False
+
+    filename: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Filename",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "Date",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    reference: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Reference",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    ifc_project: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "IfcProject",
+            "type": "Attribute",
+            "length": 22,
+            "pattern": r"[0-9,A-Z,a-z,_$]*",
+        }
+    )
+    ifc_spatial_structure_element: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "IfcSpatialStructureElement",
+            "type": "Attribute",
+            "length": 22,
+            "pattern": r"[0-9,A-Z,a-z,_$]*",
+        }
+    )
+    is_external: bool = field(
+        default=True,
+        metadata={
+            "name": "isExternal",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicDocumentReference:
+    class Meta:
+        global_type = False
+
+    referenced_document: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ReferencedDocument",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    description: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Description",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    guid: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
+    is_external: bool = field(
+        default=False,
+        metadata={
+            "name": "isExternal",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicRelatedTopic:
+    class Meta:
+        global_type = False
+
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ViewPoint:
+    viewpoint: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Viewpoint",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    snapshot: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Snapshot",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    index: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Index",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Comment:
+    date: XmlDateTime = field(
+        metadata={
+            "name": "Date",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    author: str = field(
+        metadata={
+            "name": "Author",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    comment: str = field(
+        metadata={
+            "name": "Comment",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    viewpoint: Optional[CommentViewpoint] = field(
+        default=None,
+        metadata={
+            "name": "Viewpoint",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    modified_date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedDate",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    modified_author: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedAuthor",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Header:
+    file: List[HeaderFile] = field(
+        default_factory=list,
+        metadata={
+            "name": "File",
+            "type": "Element",
+            "namespace": "",
+            "min_occurs": 1,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Topic:
+    reference_link: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "ReferenceLink",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    title: str = field(
+        metadata={
+            "name": "Title",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    priority: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Priority",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    index: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Index",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    labels: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "Labels",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    creation_date: XmlDateTime = field(
+        metadata={
+            "name": "CreationDate",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    creation_author: str = field(
+        metadata={
+            "name": "CreationAuthor",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    modified_date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedDate",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    modified_author: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedAuthor",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    due_date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "DueDate",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    assigned_to: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "AssignedTo",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    stage: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Stage",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    description: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Description",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    bim_snippet: Optional[BimSnippet] = field(
+        default=None,
+        metadata={
+            "name": "BimSnippet",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    document_reference: List[TopicDocumentReference] = field(
+        default_factory=list,
+        metadata={
+            "name": "DocumentReference",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    related_topic: List[TopicRelatedTopic] = field(
+        default_factory=list,
+        metadata={
+            "name": "RelatedTopic",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
+    topic_type: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "TopicType",
+            "type": "Attribute",
+        }
+    )
+    topic_status: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "TopicStatus",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Markup:
+    header: Optional[Header] = field(
+        default=None,
+        metadata={
+            "name": "Header",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    topic: Topic = field(
+        metadata={
+            "name": "Topic",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    comment: List[Comment] = field(
+        default_factory=list,
+        metadata={
+            "name": "Comment",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    viewpoints: List[ViewPoint] = field(
+        default_factory=list,
+        metadata={
+            "name": "Viewpoints",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
@@ -0,0 +1,41 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass(slots=True, kw_only=True)
+class Project:
+    name: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Name",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    project_id: str = field(
+        metadata={
+            "name": "ProjectId",
+            "type": "Attribute",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ProjectExtension:
+    project: Optional[Project] = field(
+        default=None,
+        metadata={
+            "name": "Project",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    extension_schema: str = field(
+        metadata={
+            "name": "ExtensionSchema",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass(slots=True, kw_only=True)
+class Version:
+    detailed_version: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "DetailedVersion",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    version_id: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "VersionId",
+            "type": "Attribute",
+        }
+    )
@@ -0,0 +1,476 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional
+
+
+class BitmapFormat(Enum):
+    PNG = "PNG"
+    JPG = "JPG"
+
+
+@dataclass(slots=True, kw_only=True)
+class Component:
+    originating_system: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "OriginatingSystem",
+            "type": "Element",
+        }
+    )
+    authoring_tool_id: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "AuthoringToolId",
+            "type": "Element",
+        }
+    )
+    ifc_guid: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "IfcGuid",
+            "type": "Attribute",
+            "length": 22,
+            "pattern": r"[0-9,A-Z,a-z,_$]*",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Direction:
+    x: float = field(
+        metadata={
+            "name": "X",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    y: float = field(
+        metadata={
+            "name": "Y",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    z: float = field(
+        metadata={
+            "name": "Z",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Point:
+    x: float = field(
+        metadata={
+            "name": "X",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    y: float = field(
+        metadata={
+            "name": "Y",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    z: float = field(
+        metadata={
+            "name": "Z",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ViewSetupHints:
+    spaces_visible: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "SpacesVisible",
+            "type": "Attribute",
+        }
+    )
+    space_boundaries_visible: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "SpaceBoundariesVisible",
+            "type": "Attribute",
+        }
+    )
+    openings_visible: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "OpeningsVisible",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ClippingPlane:
+    location: Point = field(
+        metadata={
+            "name": "Location",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    direction: Direction = field(
+        metadata={
+            "name": "Direction",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentColoringColor:
+    class Meta:
+        global_type = False
+
+    component: List[Component] = field(
+        default_factory=list,
+        metadata={
+            "name": "Component",
+            "type": "Element",
+            "min_occurs": 1,
+        }
+    )
+    color: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Color",
+            "type": "Attribute",
+            "pattern": r"[0-9,a-f,A-F]{6}([0-9,a-f,A-F]{2})?",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentSelection:
+    component: List[Component] = field(
+        default_factory=list,
+        metadata={
+            "name": "Component",
+            "type": "Element",
+            "min_occurs": 1,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentVisibilityExceptions:
+    class Meta:
+        global_type = False
+
+    component: List[Component] = field(
+        default_factory=list,
+        metadata={
+            "name": "Component",
+            "type": "Element",
+            "min_occurs": 1,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Line:
+    start_point: Point = field(
+        metadata={
+            "name": "StartPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    end_point: Point = field(
+        metadata={
+            "name": "EndPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class OrthogonalCamera:
+    """
+    Attributes
+        camera_view_point:
+        camera_direction:
+        camera_up_vector:
+        view_to_world_scale: view's visible size in meters
+    """
+    camera_view_point: Point = field(
+        metadata={
+            "name": "CameraViewPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_direction: Direction = field(
+        metadata={
+            "name": "CameraDirection",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_up_vector: Direction = field(
+        metadata={
+            "name": "CameraUpVector",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    view_to_world_scale: float = field(
+        metadata={
+            "name": "ViewToWorldScale",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class PerspectiveCamera:
+    """
+    Attributes
+        camera_view_point:
+        camera_direction:
+        camera_up_vector:
+        field_of_view: It is currently limited to a value between 45 and
+            60 degrees. This limitation will be dropped in the next
+            release and viewers should be expect values outside this
+            range in current implementations.
+    """
+    camera_view_point: Point = field(
+        metadata={
+            "name": "CameraViewPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_direction: Direction = field(
+        metadata={
+            "name": "CameraDirection",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_up_vector: Direction = field(
+        metadata={
+            "name": "CameraUpVector",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    field_of_view: float = field(
+        metadata={
+            "name": "FieldOfView",
+            "type": "Element",
+            "required": True,
+            "min_inclusive": 1.0,
+            "max_inclusive": 170.0,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfoBitmap:
+    class Meta:
+        global_type = False
+
+    bitmap: BitmapFormat = field(
+        metadata={
+            "name": "Bitmap",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    reference: str = field(
+        metadata={
+            "name": "Reference",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    location: Point = field(
+        metadata={
+            "name": "Location",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    normal: Direction = field(
+        metadata={
+            "name": "Normal",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    up: Direction = field(
+        metadata={
+            "name": "Up",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    height: float = field(
+        metadata={
+            "name": "Height",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentColoring:
+    color: List[ComponentColoringColor] = field(
+        default_factory=list,
+        metadata={
+            "name": "Color",
+            "type": "Element",
+            "min_occurs": 1,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentVisibility:
+    exceptions: Optional[ComponentVisibilityExceptions] = field(
+        default=None,
+        metadata={
+            "name": "Exceptions",
+            "type": "Element",
+        }
+    )
+    default_visibility: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "DefaultVisibility",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfoClippingPlanes:
+    class Meta:
+        global_type = False
+
+    clipping_plane: List[ClippingPlane] = field(
+        default_factory=list,
+        metadata={
+            "name": "ClippingPlane",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfoLines:
+    class Meta:
+        global_type = False
+
+    line: List[Line] = field(
+        default_factory=list,
+        metadata={
+            "name": "Line",
+            "type": "Element",
+            "min_occurs": 1,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Components:
+    view_setup_hints: Optional[ViewSetupHints] = field(
+        default=None,
+        metadata={
+            "name": "ViewSetupHints",
+            "type": "Element",
+        }
+    )
+    selection: Optional[ComponentSelection] = field(
+        default=None,
+        metadata={
+            "name": "Selection",
+            "type": "Element",
+        }
+    )
+    visibility: ComponentVisibility = field(
+        metadata={
+            "name": "Visibility",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    coloring: Optional[ComponentColoring] = field(
+        default=None,
+        metadata={
+            "name": "Coloring",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfo:
+    """
+    VisualizationInfo documentation.
+    """
+    components: Optional[Components] = field(
+        default=None,
+        metadata={
+            "name": "Components",
+            "type": "Element",
+        }
+    )
+    orthogonal_camera: Optional[OrthogonalCamera] = field(
+        default=None,
+        metadata={
+            "name": "OrthogonalCamera",
+            "type": "Element",
+        }
+    )
+    perspective_camera: Optional[PerspectiveCamera] = field(
+        default=None,
+        metadata={
+            "name": "PerspectiveCamera",
+            "type": "Element",
+        }
+    )
+    lines: Optional[VisualizationInfoLines] = field(
+        default=None,
+        metadata={
+            "name": "Lines",
+            "type": "Element",
+        }
+    )
+    clipping_planes: Optional[VisualizationInfoClippingPlanes] = field(
+        default=None,
+        metadata={
+            "name": "ClippingPlanes",
+            "type": "Element",
+        }
+    )
+    bitmap: List[VisualizationInfoBitmap] = field(
+        default_factory=list,
+        metadata={
+            "name": "Bitmap",
+            "type": "Element",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}",
+        }
+    )
@@ -0,0 +1,240 @@
+"""BCF XML V2 Topic handler."""
+import datetime
+import uuid
+import zipfile
+from pathlib import Path
+from typing import Any, Optional
+
+from ifcopenshell import entity_instance
+from xsdata.models.datatype import XmlDateTime
+
+import bcf.v2.model as mdl
+from bcf.inmemory_zipfile import ZipFileInterface
+from bcf.v2.visinfo import VisualizationInfoHandler
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+
+class TopicHandler:
+    """BCF Topic and related objects handler."""
+
+    def __init__(
+        self,
+        topic_dir: Optional[zipfile.Path] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> None:
+        self._markup: Optional[mdl.Markup] = None
+        self._viewpoints: dict[str, VisualizationInfoHandler] = {}
+        self._reference_files: dict[str, bytes] = {}
+        self._document_references: dict[str, bytes] = {}
+        self._bim_snippet: Optional[bytes] = None
+        self._xml_handler = xml_handler or XmlParserSerializer()
+        self._topic_dir = topic_dir
+
+    @property
+    def markup(self) -> Optional[mdl.Markup]:
+        if not self._markup:
+            markup_path = self._topic_dir.joinpath("markup.bcf")
+            if markup_path.exists():
+                self._markup = self._xml_handler.parse(markup_path.read_bytes(), mdl.Markup)
+        return self._markup
+
+    @markup.setter
+    def markup(self, value: mdl.Markup) -> None:
+        self._markup = value
+
+    @property
+    def topic(self) -> mdl.Topic:
+        """Return the Topic object."""
+        return self.markup.topic
+
+    @property
+    def guid(self) -> str:
+        """Return the GUID of the topic."""
+        if self._markup:
+            return self.topic.guid
+        return self._topic_dir.name if self._topic_dir else ""
+
+    @property
+    def header(self) -> Optional[mdl.Header]:
+        """Return the header of the topic."""
+        return self.markup.header if self.markup else None
+
+    @property
+    def comments(self) -> list[mdl.Comment]:
+        """Return the comments of the topic."""
+        return self.markup.comment if self.markup else []
+
+    @property
+    def bim_snippet(self) -> Optional[bytes]:
+        if not self._bim_snippet and self._topic_dir:
+            self._bim_snippet = self._load_bim_snippet()
+        return self._bim_snippet
+
+    @bim_snippet.setter
+    def bim_snippet(self, value: bytes) -> None:
+        self._bim_snippet = value
+
+    @property
+    def viewpoints(self) -> dict[str, VisualizationInfoHandler]:
+        if not self._viewpoints and self._topic_dir:
+            self._viewpoints = self._load_viewpoints()
+        return self._viewpoints
+
+    @property
+    def reference_files(self) -> dict[str, bytes]:
+        if self._reference_files or not self.header:
+            return self._reference_files
+        for ref in self.header.file:
+            if ref.is_external:
+                continue
+            real_path = self._topic_dir
+            for path_part in ref.reference.split("/"):
+                real_path = real_path.parent if path_part == ".." else real_path.joinpath(path_part)
+            self._reference_files[ref.reference] = real_path.read_bytes()
+        return self._reference_files
+
+    @property
+    def document_references(self) -> dict[str, bytes]:
+        if self._document_references or not self.topic:
+            return self._document_references
+        for doc in self.topic.document_reference:
+            if doc.is_external or not doc.referenced_document:
+                continue
+            real_path = self._topic_dir
+            for path_part in doc.referenced_document.split("/"):
+                real_path = real_path.parent if path_part == ".." else real_path.joinpath(path_part)
+            self._document_references[doc.referenced_document] = real_path.read_bytes()
+        return self._document_references
+
+    def _load_bim_snippet(self) -> Optional[bytes]:
+        bim_snippet_obj = self.topic.bim_snippet
+        if bim_snippet_obj and not bim_snippet_obj.is_external:
+            bim_snippet_path = self._topic_dir.joinpath(bim_snippet_obj.reference)
+            if bim_snippet_path.exists():
+                return bim_snippet_path.read_bytes()
+        return None
+
+    def _load_viewpoints(self) -> dict[str, VisualizationInfoHandler]:
+        if self.markup and (viewpoints := self.markup.viewpoints):
+            return VisualizationInfoHandler.from_topic_viewpoints(self._topic_dir, viewpoints)
+        return {}
+
+    @classmethod
+    def create_new(
+        cls,
+        title: str,
+        description: str,
+        author: str,
+        topic_type: str = "",
+        topic_status: str = "",
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> "TopicHandler":
+        """
+        Create a new BCF topic.
+
+        Args:
+            title: The title of the topic.
+            description: The description of the topic.
+            author: The author of the topic.
+            topic_type: The type of the topic.
+            topic_status: The status of the topic.
+            xml_handler: The XML parser/serializer to use.
+
+        Returns:
+            The BCF topic definition.
+        """
+        creation_date = XmlDateTime.from_datetime(datetime.datetime.now())
+        guid = str(uuid.uuid4())
+        topic = mdl.Topic(
+            title=title,
+            description=description,
+            creation_author=author,
+            creation_date=creation_date,
+            guid=guid,
+            topic_type=topic_type,
+            topic_status=topic_status,
+        )
+        markup = mdl.Markup(topic=topic)
+        obj = cls(topic_dir=Path(guid), xml_handler=xml_handler or XmlParserSerializer())
+        obj.markup = markup
+        return obj
+
+    def save(self, destination_zip: ZipFileInterface) -> None:
+        """
+        Save the topic to a BCF zip file.
+
+        Args:
+            bcf_zip: The BCF zip file to save to.
+        """
+        topic_dir = self.guid
+        self._save_xml(destination_zip, self._markup, "markup.bcf")
+        self._save_viewpoints(destination_zip, topic_dir)
+        self._save_bim_snippet(destination_zip)
+        self._save_reference_files(destination_zip)
+        self._save_document_references(destination_zip)
+
+    def _save_viewpoints(self, destination_zip: ZipFileInterface, topic_dir: str) -> None:
+        if not self.markup or not (viewpoints := self.markup.viewpoints):
+            return
+        for vpt in viewpoints:
+            if vpt.viewpoint:
+                self.viewpoints[vpt.viewpoint].save(destination_zip, topic_dir, vpt)
+
+    def _save_xml(self, destination_zip: ZipFileInterface, item: Any, target: str) -> None:
+        if self._topic_dir is None:
+            return
+        to_write = self._xml_handler.serialize(item) if item else self._topic_dir.joinpath(target).read_bytes()
+        destination_zip.writestr(f"{self._topic_dir.name}/{target}", to_write)
+
+    def _save_bim_snippet(self, destination_zip: ZipFileInterface) -> None:
+        snippet = self.topic.bim_snippet
+        if not snippet or snippet.is_external:
+            return
+        ref_filename = Path(snippet.reference).name
+        if self.bim_snippet:
+            destination_zip.writestr(f"{self.topic.guid}/{ref_filename}", self.bim_snippet)
+
+    def _save_reference_files(self, destination_zip: ZipFileInterface) -> None:
+        if not self.header:
+            return
+        for ref in self.header.file:
+            if ref.is_external or not ref.reference:
+                continue
+            real_path = self._topic_dir
+            for path_part in ref.reference.split("/"):
+                real_path = real_path.parent if path_part == ".." else real_path.joinpath(path_part)
+            destination_zip.writestr(real_path.at, self.reference_files[ref.reference])
+
+    def _save_document_references(self, destination_zip: ZipFileInterface) -> None:
+        if not self.topic:
+            return
+        for doc in self.topic.document_reference:
+            if doc.is_external or not doc.referenced_document:
+                continue
+            real_path = self._topic_dir
+            for path_part in doc.referenced_document.split("/"):
+                real_path = real_path.parent if path_part == ".." else real_path.joinpath(path_part)
+            destination_zip.writestr(real_path.at, self.document_references[doc.referenced_document])
+
+    def add_viewpoint(self, element: entity_instance) -> None:
+        """
+        Add a viewpoint tergeting an IFC element to the topic.
+
+        Args:
+            element: The IFC element.
+        """
+        new_viewpoint = VisualizationInfoHandler.create_new(element, self._xml_handler)
+        self.add_visinfo_handler(new_viewpoint)
+
+    def add_visinfo_handler(self, new_viewpoint: VisualizationInfoHandler) -> None:
+        self.viewpoints[new_viewpoint.guid] = new_viewpoint
+        self.markup.viewpoints.append(mdl.ViewPoint(viewpoint=new_viewpoint.guid, guid=new_viewpoint.guid))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, TopicHandler):
+            raise TypeError("Equality needs a BcfXml object.")
+        return (
+            self.markup == other.markup
+            and self.viewpoints == other.viewpoints
+            and self.bim_snippet == other.bim_snippet
+        )
@@ -0,0 +1,246 @@
+import uuid
+import zipfile
+from functools import lru_cache
+from typing import Any, Iterable, Optional
+
+import numpy as np
+from ifcopenshell import entity_instance
+from ifcopenshell.util import placement
+from numpy.typing import NDArray
+
+import bcf.v2.model as mdl
+from bcf.geometry import calc_camera_vectors
+from bcf.inmemory_zipfile import ZipFileInterface
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+
+class VisualizationInfoHandler:
+    """Handle the VisualizationInfo and related objects."""
+
+    def __init__(
+        self,
+        visualization_info: mdl.VisualizationInfo,
+        snapshot: Optional[bytes] = None,
+        bitmaps: Optional[dict[str, bytes]] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> None:
+        self.visualization_info = visualization_info
+        self.snapshot = snapshot
+        self.bitmaps = bitmaps or {}
+        self._xml_handler = xml_handler or XmlParserSerializer()
+
+    @property
+    def guid(self) -> str:
+        """Return the GUID of the visualization info."""
+        return self.visualization_info.guid
+
+    @classmethod
+    def from_topic_viewpoints(
+        cls,
+        topic_dir: zipfile.Path,
+        vps: Iterable[mdl.ViewPoint],
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> dict[str, "VisualizationInfoHandler"]:
+        """Create VisualizationInfoHandler objects of a Topic's ViewPoints."""
+        viewpoints = {}
+        for vpt in vps:
+            visinfo = cls.load(topic_dir, vpt, xml_handler)
+            if visinfo and vpt.viewpoint:
+                viewpoints[vpt.viewpoint] = visinfo
+        return viewpoints
+
+    @classmethod
+    def load(
+        cls,
+        topic_dir: zipfile.Path,
+        vpt: mdl.ViewPoint,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> Optional["VisualizationInfoHandler"]:
+        """
+        Load the VisualizationInfo and related objects from a BCF zip file.
+
+        Args:
+            topic_dir: The directory in the BCF zip file to load from.
+            vpt: The ViewPoint to load.
+            xml_handler: The XML handler to use to parse the VisualizationInfo.
+
+        Returns:
+            The VisualizationInfoHandler object.
+        """
+        visinfo = cls._load_visinfo(topic_dir, vpt.viewpoint, xml_handler)
+        if not visinfo:
+            return None
+        snapshot = cls._load_snapshot(topic_dir, vpt.snapshot)
+        bitmaps = cls._load_bitmaps(topic_dir, visinfo)
+        return cls(visinfo, snapshot, bitmaps, xml_handler)
+
+    @staticmethod
+    def _load_visinfo(
+        topic_dir: zipfile.Path,
+        vp_name: Optional[str],
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> Optional[mdl.VisualizationInfo]:
+        if not vp_name:
+            return None
+        vp_path = topic_dir.joinpath(vp_name)
+        if vp_path.exists():
+            xml_handler = xml_handler or XmlParserSerializer()
+            return xml_handler.parse(vp_path.read_bytes(), mdl.VisualizationInfo)
+        return None
+
+    @staticmethod
+    def _load_snapshot(topic_dir: zipfile.Path, vp_snapshot: Optional[str]) -> Optional[bytes]:
+        if vp_snapshot:
+            snapshot_path = topic_dir.joinpath(vp_snapshot)
+            if snapshot_path.exists():
+                return snapshot_path.read_bytes()
+        return None
+
+    @staticmethod
+    def _load_bitmaps(topic_dir: zipfile.Path, visinfo: Optional[mdl.VisualizationInfo]) -> dict[str, bytes]:
+        if not visinfo or not (bitmaps := visinfo.bitmap):
+            return {}
+        bitmaps_dict = {}
+        for bitmap in bitmaps:
+            if not bitmap.reference:
+                continue
+            bitmap_path = topic_dir.joinpath(bitmap.reference)
+            if bitmap_path.exists():
+                bitmaps_dict[bitmap.reference] = bitmap_path.read_bytes()
+        return bitmaps_dict
+
+    def save(
+        self,
+        bcf_zip: ZipFileInterface,
+        topic_dir: str,
+        vpt: mdl.ViewPoint,
+    ) -> None:
+        """
+        Save the VisualizationInfo and related objects to a BCF zip file.
+
+        Args:
+            bcf_zip: The BCF zip file to save to.
+            topic_dir: The directory in the BCF zip file to save to.
+            vpt: The ViewPoint to save.
+        """
+        if not (vp_name := vpt.viewpoint):
+            return
+        self._save_visinfo(bcf_zip, topic_dir, vp_name)
+        self._save_snapshot(bcf_zip, topic_dir, vpt.snapshot)
+        self._save_bitmaps(bcf_zip, topic_dir)
+
+    def _save_snapshot(self, bcf_zip: ZipFileInterface, topic_dir: str, filename: Optional[str]) -> None:
+        if self.snapshot and filename:
+            bcf_zip.writestr(f"{topic_dir}/{filename}", self.snapshot)
+
+    def _save_visinfo(self, bcf_zip: ZipFileInterface, topic_dir: str, vp_name: str) -> None:
+        bcf_zip.writestr(
+            f"{topic_dir}/{vp_name}",
+            self._xml_handler.serialize(self.visualization_info),
+        )
+
+    def _save_bitmaps(self, bcf_zip: ZipFileInterface, topic_dir: str) -> None:
+        if not self.bitmaps:
+            return
+        if not (bitmaps_defs := self.visualization_info.bitmap):
+            return
+        for bitmap_def in bitmaps_defs:
+            if not (bitmap_name := bitmap_def.reference):
+                continue
+            if bitmap_name in self.bitmaps:
+                bcf_zip.writestr(f"{topic_dir}/{bitmap_name}", self.bitmaps[bitmap_name])
+
+    @classmethod
+    def create_new(
+        cls,
+        element: entity_instance,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> "VisualizationInfoHandler":
+        """
+        Create a new VisualizationInfoHandler object from an IFC element.
+
+        Args:
+            element: The IFC element to point at.
+            xml_handler: The XML handler to use.
+
+        Returns:
+            The VisualizationInfoHandler object.
+        """
+        xml_handler = xml_handler or XmlParserSerializer()
+        return cls(visualization_info=build_viewpoint(element), xml_handler=xml_handler)
+
+
+@lru_cache(maxsize=None)
+def build_viewpoint(element: entity_instance) -> mdl.VisualizationInfo:
+    """
+    Return a BCF viewpoint of an IFC element.
+
+    This function is cached to speedudp the creation of multiple BCF topics regarding the same element.
+
+    Args:
+        element: The IFC element to point at.
+
+    Returns:
+        The BCF viewpoint definition.
+    """
+    elem_placement = placement.get_local_placement(element.ObjectPlacement)
+
+    return mdl.VisualizationInfo(
+        guid=str(uuid.uuid4()),
+        components=build_components(element.GlobalId),
+        perspective_camera=build_camera(elem_placement),
+    )
+
+
+def build_components(guid: str) -> mdl.Components:
+    """
+    Return the BCF components from an IFC element GUID.
+
+    Args:
+        guid: The IFC element GUID.
+
+    Returns:
+        The BCF components definition.
+    """
+    return mdl.Components(
+        selection=mdl.ComponentSelection(component=[mdl.Component(ifc_guid=guid)]),
+        visibility=mdl.ComponentVisibility(default_visibility=True),
+    )
+
+
+def build_camera(elem_placement: NDArray[np.float_]) -> mdl.PerspectiveCamera:
+    """
+    Return a BCF camera for an IFC element placement matrix.
+
+    Args:
+        elem_placement: The IFC element placement as a rototranslation matrix.
+
+    Returns:
+        The BCF camera definition.
+    """
+    return build_camera_from_vectors(*calc_camera_vectors(elem_placement))
+
+
+def build_camera_from_vectors(
+    camera_position: NDArray[np.float_], camera_dir: NDArray[np.float_], camera_up: NDArray[np.float_]
+) -> mdl.PerspectiveCamera:
+    """
+    Return a BCF camera for an IFC element placement matrix.
+
+    Args:
+        camera_position: camera position array
+        camera_dir: camera direction versor
+        camera_up_vector: camera up versor
+
+    Returns:
+        The BCF camera definition.
+    """
+    camera_viewpoint = mdl.Point(x=camera_position[0], y=camera_position[1], z=camera_position[2])
+    camera_direction = mdl.Direction(x=camera_dir[0], y=camera_dir[1], z=camera_dir[2])
+    camera_up_vector = mdl.Direction(x=camera_up[0], y=camera_up[1], z=camera_up[2])
+    return mdl.PerspectiveCamera(
+        camera_view_point=camera_viewpoint,
+        camera_direction=camera_direction,
+        camera_up_vector=camera_up_vector,
+        field_of_view=60.0,
+    )
@@ -0,0 +1 @@
+"""BCF XML v3 handler."""
@@ -0,0 +1,591 @@
+# BCF - BCF Python library
+# Copyright (C) 2021 Prabhat Singh <singh01prabhat@gmail.com>
+#
+# This file is part of BCF.
+#
+# BCF is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BCF is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with BCF.  If not, see <http://www.gnu.org/licenses/>.
+
+import base64
+import http.server
+import os
+import tempfile
+import time
+import urllib
+import uuid
+import webbrowser
+from re import A
+from typing import Any, Optional, Tuple
+
+import requests
+
+client_id, client_secret = "", ""
+
+
+class OAuthReceiver(http.server.BaseHTTPRequestHandler):
+    def do_GET(self) -> None:
+        query = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
+        self.server.auth_code = query.get("code", [""])[0]  # type:ignore
+        self.server.auth_state = query.get("state", [""])[0]  # type:ignore
+        self.send_response(200)
+        self.send_header("Content-type", "text/plain")
+        self.end_headers()
+        self.wfile.write("You have now authenticated :) You may now close this browser window.".encode("utf-8"))
+
+
+class FoundationClient:
+    def __init__(
+        self, client_id: str, client_secret: str, base_url: Optional[str] = None, redirect_subdir: Optional[str] = None
+    ) -> None:
+        self.baseurl = base_url
+        self.access_token = ""
+        self.refresh_token = ""
+        self.access_token_expires_on = time.time()
+        self.refresh_token_expires_on = float("inf")
+        self.token_endpoint = ""
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.auth_method: Optional[str] = None
+        self.redirect_subdir = redirect_subdir
+
+    def get_access_token(self) -> str:
+        if self.access_token and self.access_token_expires_on > time.time():
+            return self.access_token
+        elif self.refresh_token and self.refresh_token_expires_on > time.time():
+            self.get_refresh_token()
+        else:
+            self.login()
+        return self.access_token
+
+    def get_auth_methods(self) -> list[Any]:
+        resp = requests.get(f"{self.baseurl}foundation/1.0/auth")
+        return resp.json()["supported_oauth2_flows"]
+
+    def get_versions(self) -> list[Any]:
+        resp = requests.get(f"{self.baseurl}foundation/versions")
+        return resp.json()["versions"]
+
+    def login(self) -> None:
+        resp = requests.get(f"{self.baseurl}foundation/1.0/auth")
+        values = resp.json()
+        auth_endpoint = values["oauth2_auth_url"]
+        self.token_endpoint = values["oauth2_token_url"]
+
+        with http.server.HTTPServer(("", 8080), OAuthReceiver) as server:
+            state = str(uuid.uuid4())
+            query = urllib.parse.urlencode(
+                {
+                    "client_id": self.client_id,
+                    "response_type": "code",
+                    "state": state,
+                    "redirect_uri": f"http://localhost:{server.server_address[1]}/{self.redirect_subdir}",
+                }
+            )
+            if "?" in auth_endpoint:
+                webbrowser.open(f"{auth_endpoint}&{query}")
+            else:
+                webbrowser.open(f"{auth_endpoint}?{query}")
+            server.timeout = 100
+            server.handle_request()
+            if server.auth_code and server.auth_state == state:  # pylint: disable=E1101
+                data = {
+                    "grant_type": "authorization_code",
+                    "code": server.auth_code,  # pylint: disable=E1101 type:ignore
+                    "redirect_uri": f"http://localhost:{server.server_address[1]}/{self.redirect_subdir}",
+                }
+                headers = self._get_access_token_headers()
+                self.set_tokens_from_response(requests.post(self.token_endpoint, data=data, headers=headers))
+
+    def get_refresh_token(self) -> None:
+        self.set_tokens_from_response(
+            requests.post(
+                self.token_endpoint,
+                params={
+                    "grant_type": "refresh_token",
+                    "refresh_token": self.refresh_token,
+                },
+            ).json()
+        )
+
+    def get_new_access_token(self) -> None:
+        headers = self._get_access_token_headers()
+        self.set_tokens_from_response(
+            requests.post(
+                self.token_endpoint,
+                data={
+                    "grant_type": "refresh_token",
+                    "refresh_token": self.refresh_token,
+                },
+                headers=headers,
+            ).json()
+        )
+
+    def _get_access_token_headers(self) -> dict[str, str]:
+        auth_string = f"{self.client_id}:{self.client_secret}"
+        header_string = base64.b64encode(auth_string.encode("utf-8")).decode("utf-8")
+        return {"Authorization": f"Basic {header_string}"}
+
+    def set_auth_method(self, method: str = "authorization_code_grant") -> None:
+        if method != "authorization_code_grant":
+            raise NotImplementedError(f"{method} not supported")
+        else:
+            self.auth_method = method
+
+    def set_tokens_from_response(self, response: requests.Response) -> None:
+        response_dict = response.json()
+        self.access_token = response_dict["access_token"]
+        self.refresh_token = response_dict["refresh_token"]
+        self.access_token_expires_on = time.time() + response_dict["expires_in"]
+        if "refresh_token_expires_in" in response_dict:
+            self.refresh_token_expires_on = time.time() + response_dict["refresh_token_expires_in"]
+
+
+class BcfClient:
+    def __init__(self, foundation_client: FoundationClient) -> None:
+        self.foundation_client = foundation_client
+        self.version_id: Optional[str] = None
+        self.baseurl: Optional[str] = None
+        self.filepath = tempfile.mkdtemp()
+
+    def set_version(self, version: dict[str, str]) -> None:
+        self.version_id = version["version_id"]
+        self.baseurl = version["api_base_url"]
+
+    def get(self, endpoint: str, params: Any = None, is_auth_required: bool = False) -> Any:
+        # TODO: handle error http status codes and raise exception. Follow error.json standard.
+        headers = {"Authorization": f"Bearer {self.foundation_client.get_access_token()}"}
+
+        response = requests.get(f"{self.baseurl}{endpoint}", headers=headers, params=params or None)
+        try:
+            response = requests.get(f"{self.baseurl}{endpoint}", headers=headers, params=params or None)
+            if response.status_code == 200:
+                return response.json()
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            print(f"message: {response.reason}'   '{response.status_code}'   '{ e }")
+
+    def post(self, endpoint: str, data: Any = None, params: Any = None) -> Tuple[int, str]:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/json",
+        }
+
+        try:
+            response = requests.post(
+                f"{self.baseurl}{endpoint}", headers=headers, params=params or None, data=data or None
+            )
+
+            if response.status_code != 201:
+                response.raise_for_status()
+            return response.status_code, response.text
+        except requests.exceptions.HTTPError as errh:
+            print(f"message: {response.reason}'  '{response.status_code}, {errh}")
+            return response.status_code, response.reason
+
+    def put(self, endpoint: str, data: Any = None, params: Any = None) -> Tuple[int, str]:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/json",
+        }
+
+        try:
+            response = requests.put(
+                f"{self.baseurl}{endpoint}", headers=headers, params=params or None, data=data or None
+            )
+
+            if response.status_code != 200:
+                response.raise_for_status()
+            return response.status_code, response.text
+        except requests.exceptions.HTTPError as errh:
+            print(f"message: {response.reason}'  '{response.status_code}, {errh}")
+            return response.status_code, response.reason
+
+    def delete(self, endpoint: str, params: Any = None) -> Tuple[int, str]:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/json",
+        }
+
+        try:
+            response = requests.delete(f"{self.baseurl}{endpoint}", headers=headers, params=params or None)
+
+            if response.status_code != 200:
+                response.raise_for_status()
+            return response.status_code, response.text
+        except requests.exceptions.HTTPError as errh:
+            print(f"message: {response.reason}'  '{response.status_code}, {errh}")
+            return response.status_code, response.reason
+
+    def get_projects(self) -> list[Any]:
+        return self.get("/projects")
+
+    def get_project(self, project_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}",
+            {
+                "project_id": project_id,
+            },
+        )
+
+    def update_project(self, project_id: str = "", data: Any = None) -> Tuple[int, str]:
+        url = f"{self.baseurl}/projects/{project_id}"
+        headers = {"Authorization": f"Bearer {self.foundation_client.get_access_token()}"}
+        resp = requests.put(url, headers=headers, data=data)
+        return resp.status_code, resp.text
+
+    def get_extensions(self, project_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/extensions",
+            {
+                "project_id": project_id,
+            },
+        )
+
+    def get_topics(
+        self,
+        project_id: str = "",
+        topics: str = "",
+        query_string: Optional[str] = None,
+    ) -> list[Any]:
+        # return self.get(
+        #     f"/projects/{project_id}/topics",
+        #     {
+        #         "project_id": project_id,
+        #         "topics": topics,
+        #         "query_string": query_string,
+        #     },
+        # )
+        pass
+
+    def get_topic(self, project_id: str = "", topic_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def create_topic(self, project_id: str = "", data: Any = None) -> Tuple[int, str]:
+        return self.post(f"/projects/{project_id}/topics", data=data)
+
+    def update_topic(self, project_id: str = "", topic_id: str = "", data: Any = None) -> Tuple[int, str]:
+        return self.put(f"/projects/{project_id}/topics/{topic_id}", data=data)
+
+    def delete_topic(self, project_id: str = "", topic_id: str = "") -> Tuple[int, str]:
+        return self.delete(f"/projects/{project_id}/topics/{topic_id}")
+
+    def get_snippet(self, project_id: str = "", topic_id: str = "") -> Tuple[int, str]:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/octet-stream",
+        }
+
+        response = requests.get(f"{self.baseurl}/projects/{project_id}/topics/{topic_id}/snippet", headers=headers)
+        content = response.content.decode("utf-8")
+        with open(os.path.join(self.filepath, f"{project_id}_{topic_id}_snippet.txt"), "w") as f:
+            f.write(content)
+        return response.status_code, content
+
+    def update_snippet(self, project_id: str = "", topic_id: str = "", files: Any = None, data: Any = None) -> int:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/octet-stream",
+        }
+
+        response = requests.put(
+            f"{self.baseurl}/projects/{project_id}/topics/{topic_id}/snippet", headers=headers, files=files
+        )
+
+        return response.status_code
+
+    def get_files_information(self, project_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/files_information",
+            {
+                "project_id": project_id,
+            },
+        )
+
+    def get_files(self, project_id: str = "", topic_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/files",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def update_files(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        data: Any = None,
+        params: Any = None,
+    ) -> Tuple[int, str]:
+        return self.put(
+            f"/projects/{project_id}/topics/{topic_id}/files",
+            data=data,
+        )
+
+    def get_comments(self, project_id: str = "", topic_id: str = "") -> None:
+        pass
+
+    def create_comments(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        data: Any = None,
+        params: Any = None,
+    ) -> Tuple[int, str]:
+        return self.post(
+            f"/projects/{project_id}/topics/{topic_id}/comments",
+            data=data,
+        )
+
+    def get_comment(self, project_id: str = "", topic_id: str = "", comment_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "comment_id": comment_id,
+            },
+        )
+
+    def delete_comment(self, project_id: str = "", topic_id: str = "", comment_id: str = "") -> Tuple[int, str]:
+        return self.delete(f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}")
+
+    def update_comment(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        comment_id: str = "",
+        data: Any = None,
+    ) -> Tuple[int, str]:
+        return self.put(
+            f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}",
+            data=data,
+        )
+
+    def get_viewpoints(self, project_id: str = "", topic_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def create_viewpoints(self, project_id: str = "", topic_id: str = "", data: Any = None) -> Tuple[int, str]:
+        return self.post(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints",
+            data=data,
+        )
+
+    def get_viewpoint(self, project_id: str = "", topic_id: str = "", viewpoint_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "viewpoint_id": viewpoint_id,
+            },
+        )
+
+    def delete_viewpoint(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        viewpoint_id: str = "",
+    ) -> Tuple[int, str]:
+        return self.delete(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}",
+        )
+
+    def get_snapshot(self, project_id: str = "", topic_id: str = "", viewpoint_id: str = "") -> str:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/snapshot",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "viewpoint_id": viewpoint_id,
+            },
+        )
+
+    def get_bitmap(self, project_id: str = "", topic_id: str = "", viewpoint_id: str = "", bitmap_id: str = "") -> str:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/bitmaps/{bitmap_id}",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "viewpoint_id": viewpoint_id,
+                "bitmap_id": bitmap_id,
+            },
+        )
+
+    def get_selection(self, project_id: str = "", topic_id: str = "", viewpoint_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/selection",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "viewpoint_id": viewpoint_id,
+            },
+        )
+
+    def get_coloring(self, project_id: str = "", topic_id: str = "", viewpoint_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/coloring",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "viewpoint_id": viewpoint_id,
+            },
+        )
+
+    def get_visibility(self, project_id: str = "", topic_id: str = "", viewpoint_id: str = "") -> dict[str, Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/viewpoints/{viewpoint_id}/visibility",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "viewpoint_id": viewpoint_id,
+            },
+        )
+
+    def get_related_topics(self, project_id: str = "", topic_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/related_topics",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def update_related_topics(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        data: Any = None,
+    ) -> Tuple[int, str]:
+        return self.put(
+            f"/projects/{project_id}/topics/{topic_id}/related_topics",
+            data=data,
+        )
+
+    def get_document_references(self, project_id: str = "", topic_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/document_references",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def create_document_reference(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        data: Any = None,
+    ) -> Tuple[int, str]:
+        return self.post(
+            f"/projects/{project_id}/topics/{topic_id}/document_references",
+            data=data,
+        )
+
+    def update_document_references(
+        self,
+        project_id: str = "",
+        topic_id: str = "",
+        document_reference_id: str = "",
+        data: Any = None,
+    ) -> Tuple[int, str]:
+        return self.put(
+            f"/projects/{project_id}/topics/{topic_id}/document_references/{document_reference_id}",
+            data=data,
+        )
+
+    def get_documents(self, project_id: str = "", topic_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/documents",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def create_document(
+        self, project_id: str = "", topic_id: str = "", guid: Optional[str] = None, files: Any = None, data: Any = None
+    ) -> int:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/octet-stream",
+        }
+
+        response = requests.post(
+            f"/projects/{project_id}/topics/{topic_id}/documents",
+            data=data,
+            params={"guid": guid},
+            files=files,
+            headers=headers,
+        )
+
+        return response.status_code
+
+    def get_document(self, project_id: str = "", topic_id: str = "", document_id: str = "") -> Tuple[int, str]:
+        headers = {
+            "Authorization": f"Bearer {self.foundation_client.get_access_token()}",
+            "Content-type": "application/octet-stream",
+        }
+
+        response = requests.get(f"{self.baseurl}/projects/{project_id}/topics/documents/{document_id}", headers=headers)
+        content = response.content.decode("utf-8")
+        with open(os.path.join(self.filepath, f"{project_id}_{topic_id}_{document_id}_document.txt"), "w") as f:
+            f.write(content)
+        return response.status_code, content
+
+    def get_topics_events(self, project_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/events",
+            {
+                "project_id": project_id,
+            },
+        )
+
+    def get_topic_events(self, project_id: str = "", topic_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/events",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+            },
+        )
+
+    def get_comments_events(self, project_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/comments/events",
+            {
+                "project_id": project_id,
+            },
+        )
+
+    def get_comment_events(self, project_id: str = "", topic_id: str = "", comment_id: str = "") -> list[Any]:
+        return self.get(
+            f"/projects/{project_id}/topics/{topic_id}/comments/{comment_id}/events",
+            {
+                "project_id": project_id,
+                "topic_id": topic_id,
+                "comment_id": comment_id,
+            },
+        )
@@ -0,0 +1,291 @@
+"""BCF XML V3 handlers."""
+import uuid
+import warnings
+import zipfile
+from pathlib import Path
+from typing import Any, Optional, TypeVar
+
+import bcf.v3.model as mdl
+from bcf.inmemory_zipfile import InMemoryZipFile, ZipFileInterface
+from bcf.v3.document import DocumentsHandler
+from bcf.v3.topic import TopicHandler
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+T = TypeVar("T")
+
+
+class BcfXml:
+    """BCF XML handler."""
+
+    def __init__(
+        self, filename: Optional[Path] = None, xml_handler: Optional[AbstractXmlParserSerializer] = None
+    ) -> None:
+        self._filename = filename
+        self._xml_handler = xml_handler or XmlParserSerializer()
+        self._version: Optional[mdl.Version] = None
+        self._project_info: Optional[mdl.ProjectInfo] = None
+        self._extensions: Optional[mdl.Extensions] = None
+        self._topics: dict[str, TopicHandler] = {}
+        self._documents: Optional[DocumentsHandler] = None
+        self._zip_file = self._load_zip_file()
+
+    def __enter__(self) -> "BcfXml":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._zip_file:
+            self._zip_file.close()
+
+    def _load_zip_file(self) -> Optional[zipfile.ZipFile]:
+        return zipfile.ZipFile(self._filename) if self._filename else None
+
+    @property
+    def version(self) -> mdl.Version:
+        """Bcf Version."""
+        if not self._version:
+            self._version = (
+                self._xml_handler.parse(self._zip_file.read("bcf.version"), mdl.Version)
+                if self._zip_file
+                else mdl.Version(version_id="3.0")
+            )
+        return self._version
+
+    @version.setter
+    def version(self, value: mdl.Version) -> None:
+        self._version = value
+
+    @property
+    def project_info(self) -> Optional[mdl.ProjectInfo]:
+        """BCF project information."""
+        if not self._project_info and self._zip_file and zipfile.Path(self._zip_file, "project.bcfp").exists():
+            self._project_info = self._xml_handler.parse(self._zip_file.read("project.bcfp"), mdl.ProjectInfo)
+        return self._project_info
+
+    @project_info.setter
+    def project_info(self, value: Optional[mdl.ProjectInfo]) -> None:
+        self._project_info = value
+
+    @property
+    def project(self) -> Optional[mdl.Project]:
+        """BCF project."""
+        return self.project_info.project if self.project_info else None
+
+    @property
+    def extensions(self) -> Optional[mdl.Extensions]:
+        """BCF extensions."""
+        if not self._extensions and self._zip_file:
+            self._extensions = self._xml_handler.parse(self._zip_file.read("extensions.xml"), mdl.Extensions)
+        return self._extensions
+
+    @extensions.setter
+    def extensions(self, value: Optional[mdl.Extensions]) -> None:
+        self._extensions = value
+
+    @property
+    def topics(self) -> dict[str, TopicHandler]:
+        """BCF topics."""
+        if not self._topics and self._zip_file:
+            self._load_topics()
+        return self._topics
+
+    def _load_topics(self) -> None:
+        for topic_dir in zipfile.Path(self._zip_file).iterdir():
+            if not topic_dir.is_dir():
+                continue
+            markup_path = topic_dir.joinpath("markup.bcf")
+            if not markup_path.exists():
+                continue
+            self._topics[topic_dir.name] = TopicHandler(topic_dir, self._xml_handler)
+
+    @property
+    def documents(self) -> Optional[DocumentsHandler]:
+        """Documents stored in the BCF file."""
+        if not self._documents and self._zip_file:
+            self._documents = DocumentsHandler.load(self._zip_file, self._xml_handler)
+        return self._documents
+
+    @classmethod
+    def load(cls, filename: Path, xml_handler: Optional[AbstractXmlParserSerializer] = None) -> Optional["BcfXml"]:
+        """
+        Create a BcfXml object from a file.
+
+        Args:
+            filename: Path to the file.
+            xml_handler: XML parser and serializer.
+
+        Returns:
+            A BcfXml object with the file contents.
+
+        Raises:
+            ValueError: If the file name is null or empty
+        """
+        if not filename:
+            raise ValueError("filename is required")
+        xml_handler = xml_handler or XmlParserSerializer()
+        return cls(xml_handler=xml_handler, filename=filename)
+
+    @classmethod
+    def create_new(
+        cls,
+        project_name: Optional[str] = None,
+        extensions: Optional[mdl.Extensions] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> "BcfXml":
+        """
+        Create a new BcfXml object.
+
+        Args:
+            project_name: The name of the project.
+            extensions: The Extension XML object. Defaults to an empty one.
+            xml_handler: XML parser and serializer.
+
+        Returns:
+            A new BcfXml object.
+        """
+        instance = cls(xml_handler=xml_handler or XmlParserSerializer())
+        instance.project_info = mdl.ProjectInfo(project=mdl.Project(name=project_name, project_id=str(uuid.uuid4())))
+        instance.extensions = extensions or mdl.Extensions()
+        return instance
+
+    def save(self, filename: Optional[Path] = None, keep_open: bool = False) -> None:
+        """Save the BCF file to the given filename."""
+        if not filename and not self._filename:
+            raise ValueError("No file name specified, cannot save BCF file.")
+        if filename:
+            self._filename = filename
+        with InMemoryZipFile(self._filename) as bcf_zip:
+            self._save_project(bcf_zip)
+            self._save_version(bcf_zip)
+            self._save_extensions(bcf_zip)
+            self._save_documents(bcf_zip)
+            self._save_topics(bcf_zip)
+        if keep_open:
+            self._zip_file = self._load_zip_file()
+
+    def _save_project(self, destination_zip: ZipFileInterface) -> None:
+        self._smart_save_xml(destination_zip, self._project_info, "project.bcfp")
+
+    def _save_version(self, destination_zip: ZipFileInterface) -> None:
+        if not self._version and self._zip_file:
+            destination_zip.writestr("bcf.version", self._zip_file.read("bcf.version"))
+        else:
+            self._save_xml(destination_zip, "bcf.version", self.version)
+
+    def _save_extensions(self, destination_zip: ZipFileInterface) -> None:
+        self._smart_save_xml(destination_zip, self._extensions, "extensions.xml")
+
+    def _smart_save_xml(self, destination_zip: ZipFileInterface, item: Any, target: str) -> None:
+        if item:
+            self._save_xml(destination_zip, target, item)
+        elif self._zip_file and zipfile.Path(self._zip_file, target).exists():
+            destination_zip.writestr(target, self._zip_file.read(target))
+
+    def _save_xml(self, destination_zip: ZipFileInterface, inner_file: str, xml_obj: Any) -> None:
+        destination_zip.writestr(inner_file, self._xml_handler.serialize(xml_obj))
+
+    def _save_documents(self, bcf_zip: ZipFileInterface) -> None:
+        if self.documents:
+            self.documents.save(bcf_zip)
+
+    def _save_topics(self, destination_zip: ZipFileInterface) -> None:
+        for topic_handler in self.topics.values():
+            topic_handler.save(destination_zip)
+
+    def add_topic(
+        self, title: str, description: str, author: str, topic_type: str = "", topic_status: str = ""
+    ) -> TopicHandler:
+        """
+        Add a new topic to the BCF.
+
+        Args:
+            title: The title of the topic.
+            description: The description of the topic.
+            author: The author of the topic.
+            topic_type: The type of the topic.
+            topic_status: The status of the topic.
+
+        Returns:
+            The newly created topic wrapped inside a TopicHandler object.
+        """
+        topic_handler = TopicHandler.create_new(
+            title,
+            description,
+            author,
+            topic_type=topic_type,
+            topic_status=topic_status,
+            xml_handler=self._xml_handler,
+        )
+        self.topics[topic_handler.guid] = topic_handler
+        return topic_handler
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BcfXml):
+            raise TypeError("Equality needs a BcfXml object.")
+        return (
+            self.version == other.version
+            and self.project_info == other.project_info
+            and self.extensions == other.extensions
+        )
+
+    # region Deprecated methods
+    def new_project(self) -> "BcfXml":
+        """Deprecated method."""
+        warnings.warn("new_project is deprecated, use create_new instead.", DeprecationWarning)
+        return self.create_new()
+
+    def get_project(self, _filepath: Optional[str] = None) -> Optional[mdl.Project]:
+        """Deprecated method."""
+        warnings.warn("get_project is deprecated, use project_info.project instead.", DeprecationWarning)
+        return self.project
+
+    def edit_project(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_project is deprecated, there's no need to use it.", DeprecationWarning)
+
+    def save_project(self, filepath: Path) -> None:
+        """Deprecated method."""
+        warnings.warn("save_project is deprecated, use save instead.", DeprecationWarning)
+        self.save(filepath)
+
+    def get_version(self) -> str:
+        warnings.warn("get_version is deprecated, use version.version_id instead.", DeprecationWarning)
+        return self.version.version_id
+
+    def edit_version(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_version is deprecated, there's no need to use it.", DeprecationWarning)
+
+    def get_topics(self) -> dict[str, TopicHandler]:
+        """Deprecated method."""
+        warnings.warn("get_topics is deprecated, use topics instead.", DeprecationWarning)
+        return self.topics
+
+    def get_topic(self, guid: str) -> TopicHandler:
+        """Return a topic by its GUID."""
+        warnings.warn("get_topic is deprecated, use topics[guid] instead", DeprecationWarning)
+        return self.topics[guid]
+
+    def get_header(self, guid: str) -> Optional[mdl.Header]:
+        """Return the header of a Topic by its GUID."""
+        return self.topics[guid].header
+
+    def edit_topic(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_topic is deprecated, there's no need to use it.", DeprecationWarning)
+
+    def add_comment(self, _topic: mdl.Topic, _comment: Optional[mdl.Comment] = None) -> None:
+        """Deprecated method."""
+        warnings.warn("add_comment is deprecated, use topics methods instead.", DeprecationWarning)
+
+    def edit_comment(self) -> None:
+        """Deprecated method."""
+        warnings.warn("edit_comment is deprecated, there's no need to use it.", DeprecationWarning)
+
+    # TODO: deprecate other methods
+    # endregion
@@ -0,0 +1,61 @@
+"""BCF XML V3 Documents handler."""
+import zipfile
+from typing import Any, Optional
+
+import bcf.v3.model as mdl
+from bcf.inmemory_zipfile import ZipFileInterface
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+
+class DocumentsHandler:
+    """BCF documents handler."""
+
+    def __init__(
+        self,
+        definition: mdl.DocumentInfo,
+        documents: Optional[dict[str, bytes]] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> None:
+        self.definition = definition
+        self.documents = documents or {}
+        self._xml_handler = xml_handler or XmlParserSerializer()
+
+    @classmethod
+    def load(
+        cls,
+        zip_file: zipfile.ZipFile,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> Optional["DocumentsHandler"]:
+        """
+        Loads the documents from the given zip file directory.
+
+        Args:
+            zip_path: The directory path inside the zip file.
+            xml_handler: The xml parser/serializer to use.
+
+        Returns:
+            The documents handler.
+        """
+        xml_handler = xml_handler or XmlParserSerializer()
+        file_to_open = zipfile.Path(zip_file, "documents.xml")
+        if not file_to_open.exists():
+            return None
+        definition = xml_handler.parse(file_to_open.read_bytes(), mdl.DocumentInfo)
+        documents = {}
+        if def_docs := definition.documents:
+            for document in def_docs.document:
+                document_path = zipfile.Path(zip_file, f"documents/{document.guid}")
+                if document_path.exists():
+                    documents[document.filename] = document_path.read_bytes()
+        return cls(definition, documents=documents)
+
+    def save(self, bcf_zip: ZipFileInterface) -> None:
+        """Save the documents to the zip file."""
+        bcf_zip.writestr("documents.xml", self._xml_handler.serialize(self.definition))
+        if documents := self.definition.documents:
+            for doc in documents.document:
+                if doc.filename in self.documents:
+                    bcf_zip.writestr(
+                        f"documents/{doc.guid}",
+                        self.documents[doc.filename],
+                    )
@@ -0,0 +1,110 @@
+from bcf.v3.model.documents import Document, DocumentInfo, DocumentInfoDocuments
+from bcf.v3.model.extensions import (
+    Extensions,
+    ExtensionsPriorities,
+    ExtensionsSnippetTypes,
+    ExtensionsStages,
+    ExtensionsTopicLabels,
+    ExtensionsTopicStatuses,
+    ExtensionsTopicTypes,
+    ExtensionsUsers,
+)
+from bcf.v3.model.markup import (
+    BimSnippet,
+    Comment,
+    CommentViewpoint,
+    DocumentReference,
+    File,
+    Header,
+    HeaderFiles,
+    Markup,
+    Topic,
+    TopicComments,
+    TopicDocumentReferences,
+    TopicLabels,
+    TopicReferenceLinks,
+    TopicRelatedTopics,
+    TopicRelatedTopicsRelatedTopic,
+    TopicViewpoints,
+    ViewPoint,
+)
+from bcf.v3.model.project import Project, ProjectInfo
+from bcf.v3.model.version import Version
+from bcf.v3.model.visinfo import (
+    Bitmap,
+    BitmapFormat,
+    ClippingPlane,
+    Component,
+    ComponentColoring,
+    ComponentColoringColor,
+    ComponentColoringColorComponents,
+    Components,
+    ComponentSelection,
+    ComponentVisibility,
+    ComponentVisibilityExceptions,
+    Direction,
+    Line,
+    OrthogonalCamera,
+    PerspectiveCamera,
+    Point,
+    ViewSetupHints,
+    VisualizationInfo,
+    VisualizationInfoBitmaps,
+    VisualizationInfoClippingPlanes,
+    VisualizationInfoLines,
+)
+
+__all__ = [
+    "Document",
+    "DocumentInfo",
+    "DocumentInfoDocuments",
+    "Extensions",
+    "ExtensionsPriorities",
+    "ExtensionsSnippetTypes",
+    "ExtensionsStages",
+    "ExtensionsTopicLabels",
+    "ExtensionsTopicStatuses",
+    "ExtensionsTopicTypes",
+    "ExtensionsUsers",
+    "BimSnippet",
+    "Comment",
+    "CommentViewpoint",
+    "DocumentReference",
+    "File",
+    "Header",
+    "HeaderFiles",
+    "Markup",
+    "Topic",
+    "TopicComments",
+    "TopicDocumentReferences",
+    "TopicLabels",
+    "TopicReferenceLinks",
+    "TopicRelatedTopics",
+    "TopicRelatedTopicsRelatedTopic",
+    "TopicViewpoints",
+    "ViewPoint",
+    "Project",
+    "ProjectInfo",
+    "Version",
+    "Bitmap",
+    "BitmapFormat",
+    "ClippingPlane",
+    "Component",
+    "ComponentColoring",
+    "ComponentColoringColor",
+    "ComponentColoringColorComponents",
+    "ComponentSelection",
+    "ComponentVisibility",
+    "ComponentVisibilityExceptions",
+    "Components",
+    "Direction",
+    "Line",
+    "OrthogonalCamera",
+    "PerspectiveCamera",
+    "Point",
+    "ViewSetupHints",
+    "VisualizationInfo",
+    "VisualizationInfoBitmaps",
+    "VisualizationInfoClippingPlanes",
+    "VisualizationInfoLines",
+]
@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass(slots=True, kw_only=True)
+class Document:
+    filename: str = field(
+        metadata={
+            "name": "Filename",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    description: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Description",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class DocumentInfoDocuments:
+    class Meta:
+        global_type = False
+
+    document: List[Document] = field(
+        default_factory=list,
+        metadata={
+            "name": "Document",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class DocumentInfo:
+    documents: Optional[DocumentInfoDocuments] = field(
+        default=None,
+        metadata={
+            "name": "Documents",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
@@ -0,0 +1,181 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsPriorities:
+    class Meta:
+        global_type = False
+
+    priority: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "Priority",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsSnippetTypes:
+    class Meta:
+        global_type = False
+
+    snippet_type: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "SnippetType",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsStages:
+    class Meta:
+        global_type = False
+
+    stage: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "Stage",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsTopicLabels:
+    class Meta:
+        global_type = False
+
+    topic_label: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "TopicLabel",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsTopicStatuses:
+    class Meta:
+        global_type = False
+
+    topic_status: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "TopicStatus",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsTopicTypes:
+    class Meta:
+        global_type = False
+
+    topic_type: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "TopicType",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ExtensionsUsers:
+    class Meta:
+        global_type = False
+
+    user: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "User",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Extensions:
+    topic_types: Optional[ExtensionsTopicTypes] = field(
+        default=None,
+        metadata={
+            "name": "TopicTypes",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    topic_statuses: Optional[ExtensionsTopicStatuses] = field(
+        default=None,
+        metadata={
+            "name": "TopicStatuses",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    priorities: Optional[ExtensionsPriorities] = field(
+        default=None,
+        metadata={
+            "name": "Priorities",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    topic_labels: Optional[ExtensionsTopicLabels] = field(
+        default=None,
+        metadata={
+            "name": "TopicLabels",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    users: Optional[ExtensionsUsers] = field(
+        default=None,
+        metadata={
+            "name": "Users",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    snippet_types: Optional[ExtensionsSnippetTypes] = field(
+        default=None,
+        metadata={
+            "name": "SnippetTypes",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    stages: Optional[ExtensionsStages] = field(
+        default=None,
+        metadata={
+            "name": "Stages",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
@@ -0,0 +1,616 @@
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from xsdata.models.datatype import XmlDateTime
+
+
+@dataclass(slots=True, kw_only=True)
+class BimSnippet:
+    reference: str = field(
+        metadata={
+            "name": "Reference",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    reference_schema: str = field(
+        metadata={
+            "name": "ReferenceSchema",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    snippet_type: str = field(
+        metadata={
+            "name": "SnippetType",
+            "type": "Attribute",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    is_external: bool = field(
+        default=False,
+        metadata={
+            "name": "IsExternal",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class CommentViewpoint:
+    class Meta:
+        global_type = False
+
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class DocumentReference:
+    document_guid: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "DocumentGuid",
+            "type": "Element",
+            "namespace": "",
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+    url: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Url",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    description: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Description",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class File:
+    filename: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Filename",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "Date",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    reference: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Reference",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    ifc_project: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "IfcProject",
+            "type": "Attribute",
+            "length": 22,
+            "pattern": r"[0-9A-Za-z_$]*",
+        }
+    )
+    ifc_spatial_structure_element: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "IfcSpatialStructureElement",
+            "type": "Attribute",
+            "length": 22,
+            "pattern": r"[0-9A-Za-z_$]*",
+        }
+    )
+    is_external: bool = field(
+        default=True,
+        metadata={
+            "name": "IsExternal",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicLabels:
+    class Meta:
+        global_type = False
+
+    label: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "Label",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicReferenceLinks:
+    class Meta:
+        global_type = False
+
+    reference_link: List[str] = field(
+        default_factory=list,
+        metadata={
+            "name": "ReferenceLink",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicRelatedTopicsRelatedTopic:
+    class Meta:
+        global_type = False
+
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ViewPoint:
+    viewpoint: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Viewpoint",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    snapshot: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Snapshot",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    index: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Index",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Comment:
+    date: XmlDateTime = field(
+        metadata={
+            "name": "Date",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    author: str = field(
+        metadata={
+            "name": "Author",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    comment: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Comment",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    viewpoint: Optional[CommentViewpoint] = field(
+        default=None,
+        metadata={
+            "name": "Viewpoint",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    modified_date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedDate",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    modified_author: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedAuthor",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class HeaderFiles:
+    class Meta:
+        global_type = False
+
+    file: List[File] = field(
+        default_factory=list,
+        metadata={
+            "name": "File",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicDocumentReferences:
+    class Meta:
+        global_type = False
+
+    document_reference: List[DocumentReference] = field(
+        default_factory=list,
+        metadata={
+            "name": "DocumentReference",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicRelatedTopics:
+    class Meta:
+        global_type = False
+
+    related_topic: List[TopicRelatedTopicsRelatedTopic] = field(
+        default_factory=list,
+        metadata={
+            "name": "RelatedTopic",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicViewpoints:
+    class Meta:
+        global_type = False
+
+    view_point: List[ViewPoint] = field(
+        default_factory=list,
+        metadata={
+            "name": "ViewPoint",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Header:
+    files: Optional[HeaderFiles] = field(
+        default=None,
+        metadata={
+            "name": "Files",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class TopicComments:
+    class Meta:
+        global_type = False
+
+    comment: List[Comment] = field(
+        default_factory=list,
+        metadata={
+            "name": "Comment",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Topic:
+    reference_links: Optional[TopicReferenceLinks] = field(
+        default=None,
+        metadata={
+            "name": "ReferenceLinks",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    title: str = field(
+        metadata={
+            "name": "Title",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    priority: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Priority",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    index: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Index",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    labels: Optional[TopicLabels] = field(
+        default=None,
+        metadata={
+            "name": "Labels",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    creation_date: XmlDateTime = field(
+        metadata={
+            "name": "CreationDate",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
+    creation_author: str = field(
+        metadata={
+            "name": "CreationAuthor",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    modified_date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedDate",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    modified_author: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ModifiedAuthor",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    due_date: Optional[XmlDateTime] = field(
+        default=None,
+        metadata={
+            "name": "DueDate",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    assigned_to: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "AssignedTo",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    stage: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Stage",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    description: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Description",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    bim_snippet: Optional[BimSnippet] = field(
+        default=None,
+        metadata={
+            "name": "BimSnippet",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    document_references: Optional[TopicDocumentReferences] = field(
+        default=None,
+        metadata={
+            "name": "DocumentReferences",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    related_topics: Optional[TopicRelatedTopics] = field(
+        default=None,
+        metadata={
+            "name": "RelatedTopics",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    comments: Optional[TopicComments] = field(
+        default=None,
+        metadata={
+            "name": "Comments",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    viewpoints: Optional[TopicViewpoints] = field(
+        default=None,
+        metadata={
+            "name": "Viewpoints",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
+    server_assigned_id: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ServerAssignedId",
+            "type": "Attribute",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    topic_type: str = field(
+        metadata={
+            "name": "TopicType",
+            "type": "Attribute",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    topic_status: str = field(
+        metadata={
+            "name": "TopicStatus",
+            "type": "Attribute",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Markup:
+    header: Optional[Header] = field(
+        default=None,
+        metadata={
+            "name": "Header",
+            "type": "Element",
+            "namespace": "",
+        }
+    )
+    topic: Topic = field(
+        metadata={
+            "name": "Topic",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass(slots=True, kw_only=True)
+class Project:
+    name: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "Name",
+            "type": "Element",
+            "namespace": "",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    project_id: str = field(
+        metadata={
+            "name": "ProjectId",
+            "type": "Attribute",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ProjectInfo:
+    project: Project = field(
+        metadata={
+            "name": "Project",
+            "type": "Element",
+            "namespace": "",
+            "required": True,
+        }
+    )
@@ -0,0 +1,12 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True, kw_only=True)
+class Version:
+    version_id: str = field(
+        metadata={
+            "name": "VersionId",
+            "type": "Attribute",
+            "required": True,
+        }
+    )
@@ -0,0 +1,524 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional
+
+
+class BitmapFormat(Enum):
+    PNG = "png"
+    JPG = "jpg"
+
+
+@dataclass(slots=True, kw_only=True)
+class Component:
+    originating_system: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "OriginatingSystem",
+            "type": "Element",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    authoring_tool_id: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "AuthoringToolId",
+            "type": "Element",
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    ifc_guid: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "IfcGuid",
+            "type": "Attribute",
+            "length": 22,
+            "pattern": r"[0-9A-Za-z_$]*",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Direction:
+    x: float = field(
+        metadata={
+            "name": "X",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    y: float = field(
+        metadata={
+            "name": "Y",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    z: float = field(
+        metadata={
+            "name": "Z",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Point:
+    x: float = field(
+        metadata={
+            "name": "X",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    y: float = field(
+        metadata={
+            "name": "Y",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    z: float = field(
+        metadata={
+            "name": "Z",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ViewSetupHints:
+    spaces_visible: bool = field(
+        default=False,
+        metadata={
+            "name": "SpacesVisible",
+            "type": "Attribute",
+        }
+    )
+    space_boundaries_visible: bool = field(
+        default=False,
+        metadata={
+            "name": "SpaceBoundariesVisible",
+            "type": "Attribute",
+        }
+    )
+    openings_visible: bool = field(
+        default=False,
+        metadata={
+            "name": "OpeningsVisible",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Bitmap:
+    format: BitmapFormat = field(
+        metadata={
+            "name": "Format",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    reference: str = field(
+        metadata={
+            "name": "Reference",
+            "type": "Element",
+            "required": True,
+            "min_length": 1,
+            "white_space": "collapse",
+        }
+    )
+    location: Point = field(
+        metadata={
+            "name": "Location",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    normal: Direction = field(
+        metadata={
+            "name": "Normal",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    up: Direction = field(
+        metadata={
+            "name": "Up",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    height: float = field(
+        metadata={
+            "name": "Height",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ClippingPlane:
+    location: Point = field(
+        metadata={
+            "name": "Location",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    direction: Direction = field(
+        metadata={
+            "name": "Direction",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentColoringColorComponents:
+    class Meta:
+        global_type = False
+
+    component: List[Component] = field(
+        default_factory=list,
+        metadata={
+            "name": "Component",
+            "type": "Element",
+            "min_occurs": 1,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentSelection:
+    component: List[Component] = field(
+        default_factory=list,
+        metadata={
+            "name": "Component",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentVisibilityExceptions:
+    class Meta:
+        global_type = False
+
+    component: List[Component] = field(
+        default_factory=list,
+        metadata={
+            "name": "Component",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Line:
+    start_point: Point = field(
+        metadata={
+            "name": "StartPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    end_point: Point = field(
+        metadata={
+            "name": "EndPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class OrthogonalCamera:
+    """
+    Attributes
+        camera_view_point:
+        camera_direction:
+        camera_up_vector:
+        view_to_world_scale: view's visible vertical size in meters
+        aspect_ratio: Proportional relationship between the width and
+            the height of the view (w/h).
+    """
+    camera_view_point: Point = field(
+        metadata={
+            "name": "CameraViewPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_direction: Direction = field(
+        metadata={
+            "name": "CameraDirection",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_up_vector: Direction = field(
+        metadata={
+            "name": "CameraUpVector",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    view_to_world_scale: float = field(
+        metadata={
+            "name": "ViewToWorldScale",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    aspect_ratio: float = field(
+        metadata={
+            "name": "AspectRatio",
+            "type": "Element",
+            "required": True,
+            "min_exclusive": 0.0,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class PerspectiveCamera:
+    """
+    Attributes
+        camera_view_point:
+        camera_direction:
+        camera_up_vector:
+        field_of_view: Vertical field of view, in degrees. It is
+            currently limited to a value between 45 and 60 degrees. This
+            limitation will be dropped in the next release and viewers
+            should be expect values outside this range in current
+            implementations.
+        aspect_ratio: Proportional relationship between the width and
+            the height of the view (w/h).
+    """
+    camera_view_point: Point = field(
+        metadata={
+            "name": "CameraViewPoint",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_direction: Direction = field(
+        metadata={
+            "name": "CameraDirection",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    camera_up_vector: Direction = field(
+        metadata={
+            "name": "CameraUpVector",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    field_of_view: float = field(
+        metadata={
+            "name": "FieldOfView",
+            "type": "Element",
+            "required": True,
+            "min_exclusive": 0.0,
+            "max_exclusive": 180.0,
+        }
+    )
+    aspect_ratio: float = field(
+        metadata={
+            "name": "AspectRatio",
+            "type": "Element",
+            "required": True,
+            "min_exclusive": 0.0,
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentColoringColor:
+    class Meta:
+        global_type = False
+
+    components: ComponentColoringColorComponents = field(
+        metadata={
+            "name": "Components",
+            "type": "Element",
+            "required": True,
+        }
+    )
+    color: str = field(
+        metadata={
+            "name": "Color",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentVisibility:
+    view_setup_hints: Optional[ViewSetupHints] = field(
+        default=None,
+        metadata={
+            "name": "ViewSetupHints",
+            "type": "Element",
+        }
+    )
+    exceptions: Optional[ComponentVisibilityExceptions] = field(
+        default=None,
+        metadata={
+            "name": "Exceptions",
+            "type": "Element",
+        }
+    )
+    default_visibility: bool = field(
+        default=False,
+        metadata={
+            "name": "DefaultVisibility",
+            "type": "Attribute",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfoBitmaps:
+    class Meta:
+        global_type = False
+
+    bitmap: List[Bitmap] = field(
+        default_factory=list,
+        metadata={
+            "name": "Bitmap",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfoClippingPlanes:
+    class Meta:
+        global_type = False
+
+    clipping_plane: List[ClippingPlane] = field(
+        default_factory=list,
+        metadata={
+            "name": "ClippingPlane",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfoLines:
+    class Meta:
+        global_type = False
+
+    line: List[Line] = field(
+        default_factory=list,
+        metadata={
+            "name": "Line",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class ComponentColoring:
+    color: List[ComponentColoringColor] = field(
+        default_factory=list,
+        metadata={
+            "name": "Color",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class Components:
+    selection: Optional[ComponentSelection] = field(
+        default=None,
+        metadata={
+            "name": "Selection",
+            "type": "Element",
+        }
+    )
+    visibility: Optional[ComponentVisibility] = field(
+        default=None,
+        metadata={
+            "name": "Visibility",
+            "type": "Element",
+        }
+    )
+    coloring: Optional[ComponentColoring] = field(
+        default=None,
+        metadata={
+            "name": "Coloring",
+            "type": "Element",
+        }
+    )
+
+
+@dataclass(slots=True, kw_only=True)
+class VisualizationInfo:
+    """
+    VisualizationInfo documentation.
+    """
+    components: Optional[Components] = field(
+        default=None,
+        metadata={
+            "name": "Components",
+            "type": "Element",
+        }
+    )
+    orthogonal_camera: Optional[OrthogonalCamera] = field(
+        default=None,
+        metadata={
+            "name": "OrthogonalCamera",
+            "type": "Element",
+        }
+    )
+    perspective_camera: Optional[PerspectiveCamera] = field(
+        default=None,
+        metadata={
+            "name": "PerspectiveCamera",
+            "type": "Element",
+        }
+    )
+    lines: Optional[VisualizationInfoLines] = field(
+        default=None,
+        metadata={
+            "name": "Lines",
+            "type": "Element",
+        }
+    )
+    clipping_planes: Optional[VisualizationInfoClippingPlanes] = field(
+        default=None,
+        metadata={
+            "name": "ClippingPlanes",
+            "type": "Element",
+        }
+    )
+    bitmaps: Optional[VisualizationInfoBitmaps] = field(
+        default=None,
+        metadata={
+            "name": "Bitmaps",
+            "type": "Element",
+        }
+    )
+    guid: str = field(
+        metadata={
+            "name": "Guid",
+            "type": "Attribute",
+            "required": True,
+            "pattern": r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}",
+        }
+    )
@@ -0,0 +1,188 @@
+"""BCF XML V3 Topic handler."""
+import datetime
+import uuid
+import zipfile
+from pathlib import Path
+from typing import Any, Optional
+
+from ifcopenshell import entity_instance
+from xsdata.models.datatype import XmlDateTime
+
+import bcf.v3.model as mdl
+from bcf.inmemory_zipfile import ZipFileInterface
+from bcf.v3.visinfo import VisualizationInfoHandler
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+
+class TopicHandler:
+    """BCF Topic and related objects handler."""
+
+    def __init__(
+        self,
+        topic_dir: Optional[zipfile.Path] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> None:
+        self._markup: Optional[mdl.Markup] = None
+        self._viewpoints: dict[str, VisualizationInfoHandler] = {}
+        self._bim_snippet: Optional[bytes] = None
+        self._xml_handler = xml_handler or XmlParserSerializer()
+        self._topic_dir = topic_dir
+
+    @property
+    def markup(self) -> Optional[mdl.Markup]:
+        if not self._markup and self._topic_dir:
+            markup_path = self._topic_dir.joinpath("markup.bcf")
+            if markup_path.exists():
+                self._markup = self._xml_handler.parse(markup_path.read_bytes(), mdl.Markup)
+        return self._markup
+
+    @markup.setter
+    def markup(self, value: mdl.Markup) -> None:
+        self._markup = value
+
+    @property
+    def topic(self) -> mdl.Topic:
+        """Return the Topic object."""
+        return self.markup.topic
+
+    @property
+    def guid(self) -> Optional[str]:
+        """Return the GUID of the topic."""
+        if self._markup:
+            return self.topic.guid
+        return self._topic_dir.name if self._topic_dir else None
+
+    @property
+    def header(self) -> Optional[mdl.Header]:
+        """Return the header of the topic."""
+        return self.markup.header
+
+    @property
+    def comments(self) -> list[mdl.Comment]:
+        """Return the comments of the topic."""
+        return self.topic.comments.comment if self.topic.comments else []
+
+    @property
+    def bim_snippet(self) -> Optional[bytes]:
+        if not self._bim_snippet and self._topic_dir:
+            self._bim_snippet = self._load_bim_snippet()
+        return self._bim_snippet
+
+    @bim_snippet.setter
+    def bim_snippet(self, value: bytes) -> None:
+        self._bim_snippet = value
+
+    @property
+    def viewpoints(self) -> Optional[VisualizationInfoHandler]:
+        if (
+            not self._viewpoints
+            and self._topic_dir
+            and self.topic.viewpoints
+            and (viewpoints := self.topic.viewpoints.view_point)
+        ):
+            self._viewpoints = VisualizationInfoHandler.from_topic_viewpoints(self._topic_dir, viewpoints)
+        return self._viewpoints
+
+    def _load_bim_snippet(self) -> Optional[bytes]:
+        bim_snippet_obj = self.topic.bim_snippet
+        if bim_snippet_obj and not bim_snippet_obj.is_external and self._topic_dir:
+            bim_snippet_path = self._topic_dir.joinpath(bim_snippet_obj.reference)
+            if bim_snippet_path.exists():
+                return bim_snippet_path.read_bytes()
+        return None
+
+    @classmethod
+    def create_new(
+        cls,
+        title: str,
+        description: str,
+        author: str,
+        topic_type: str = "",
+        topic_status: str = "",
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> "TopicHandler":
+        """
+        Create a new BCF topic.
+
+        Args:
+            title: The title of the topic.
+            description: The description of the topic.
+            author: The author of the topic.
+            topic_type: The type of the topic.
+            topic_status: The status of the topic.
+            xml_handler: The XML parser/serializer to use.
+
+        Returns:
+            The BCF topic definition.
+        """
+        creation_date = XmlDateTime.from_datetime(datetime.datetime.now())
+        guid = str(uuid.uuid4())
+        topic = mdl.Topic(
+            title=title,
+            description=description,
+            creation_author=author,
+            creation_date=creation_date,
+            guid=guid,
+            topic_type=topic_type,
+            topic_status=topic_status,
+        )
+        markup = mdl.Markup(topic=topic)
+        obj = cls(topic_dir=Path(guid), xml_handler=xml_handler or XmlParserSerializer())
+        obj.markup = markup
+        return obj
+
+    def save(self, destination_zip: ZipFileInterface) -> None:
+        """
+        Save the topic to a BCF zip file.
+
+        Args:
+            bcf_zip: The BCF zip file to save to.
+        """
+        topic_dir = self.guid
+        self._save_xml(destination_zip, self._markup, "markup.bcf")
+        self._save_viewpoints(destination_zip, topic_dir)
+        self._save_bim_snippet(destination_zip)
+
+    def _save_viewpoints(self, destination_zip, topic_dir) -> None:
+        if not self.topic.viewpoints or not (viewpoints := self.topic.viewpoints.view_point):
+            return
+        for vpt in viewpoints:
+            if vpt.viewpoint:
+                self.viewpoints[vpt.viewpoint].save(destination_zip, topic_dir, vpt)
+
+    def _save_xml(self, destination_zip: ZipFileInterface, item: Any, target: str) -> None:
+        to_write = self._xml_handler.serialize(item) if item else self._topic_dir.joinpath(target).read_bytes()
+        destination_zip.writestr(f"{self._topic_dir.name}/{target}", to_write)
+
+    def _save_bim_snippet(self, destination_zip: ZipFileInterface) -> None:
+        snippet = self.topic.bim_snippet
+        if not snippet or snippet.is_external:
+            return
+        ref_filename = Path(snippet.reference).name
+        if self.bim_snippet:
+            destination_zip.writestr(f"{self.topic.guid}/{ref_filename}", self.bim_snippet)
+
+    def add_viewpoint(self, element: entity_instance) -> None:
+        """
+        Add a viewpoint tergeting an IFC element to the topic.
+
+        Args:
+            element: The IFC element.
+        """
+        new_viewpoint = VisualizationInfoHandler.create_new(element, self._xml_handler)
+        self.add_visinfo_handler(new_viewpoint)
+
+    def add_visinfo_handler(self, new_viewpoint: VisualizationInfoHandler) -> None:
+        self.viewpoints[new_viewpoint.guid] = new_viewpoint
+        if self.topic.viewpoints is None:
+            self.topic.viewpoints = mdl.TopicViewpoints()
+        self.topic.viewpoints.view_point.append(mdl.ViewPoint(viewpoint=new_viewpoint.guid, guid=new_viewpoint.guid))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, TopicHandler):
+            raise TypeError("Equality needs a BcfXml object.")
+        return (
+            self.markup == other.markup
+            and self.viewpoints == other.viewpoints
+            and self.bim_snippet == other.bim_snippet
+        )
@@ -0,0 +1,247 @@
+import uuid
+import zipfile
+from functools import lru_cache
+from typing import Any, Iterable, Optional
+
+import numpy as np
+from ifcopenshell import entity_instance
+from ifcopenshell.util import placement
+from numpy.typing import NDArray
+
+import bcf.v3.model as mdl
+from bcf.geometry import calc_camera_vectors
+from bcf.inmemory_zipfile import ZipFileInterface
+from bcf.xml_parser import AbstractXmlParserSerializer, XmlParserSerializer
+
+
+class VisualizationInfoHandler:
+    """Handle the VisualizationInfo and related objects."""
+
+    def __init__(
+        self,
+        visualization_info: mdl.VisualizationInfo,
+        snapshot: Optional[bytes] = None,
+        bitmaps: Optional[dict[str, bytes]] = None,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> None:
+        self.visualization_info = visualization_info
+        self.snapshot = snapshot
+        self.bitmaps = bitmaps or {}
+        self._xml_handler = xml_handler or XmlParserSerializer()
+
+    @property
+    def guid(self) -> str:
+        """Return the GUID of the visualization info."""
+        return self.visualization_info.guid
+
+    @classmethod
+    def from_topic_viewpoints(
+        cls,
+        topic_dir: zipfile.Path,
+        vps: Iterable[mdl.ViewPoint],
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> dict[str, "VisualizationInfoHandler"]:
+        """Create VisualizationInfoHandler objects of a Topic's ViewPoints."""
+        viewpoints = {}
+        for vpt in vps:
+            visinfo = cls.load(topic_dir, vpt, xml_handler)
+            if visinfo and vpt.viewpoint:
+                viewpoints[vpt.viewpoint] = visinfo
+        return viewpoints
+
+    @classmethod
+    def load(
+        cls,
+        topic_dir: zipfile.Path,
+        vpt: mdl.ViewPoint,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> Optional["VisualizationInfoHandler"]:
+        """
+        Load the VisualizationInfo and related objects from a BCF zip file.
+
+        Args:
+            topic_dir: The directory in the BCF zip file to load from.
+            vpt: The ViewPoint to load.
+            xml_handler: The XML handler to use to parse the VisualizationInfo.
+
+        Returns:
+            The VisualizationInfoHandler object.
+        """
+        visinfo = cls._load_visinfo(topic_dir, vpt.viewpoint, xml_handler)
+        if not visinfo:
+            return None
+        snapshot = cls._load_snapshot(topic_dir, vpt.snapshot)
+        bitmaps = cls._load_bitmaps(topic_dir, visinfo)
+        return cls(visinfo, snapshot, bitmaps, xml_handler)
+
+    @staticmethod
+    def _load_visinfo(
+        topic_dir: zipfile.Path,
+        vp_name: Optional[str],
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> Optional[mdl.VisualizationInfo]:
+        if not vp_name:
+            return None
+        vp_path = topic_dir.joinpath(vp_name)
+        if vp_path.exists():
+            xml_handler = xml_handler or XmlParserSerializer()
+            return xml_handler.parse(vp_path.read_bytes(), mdl.VisualizationInfo)
+        return None
+
+    @staticmethod
+    def _load_snapshot(topic_dir: zipfile.Path, vp_snapshot: Optional[str]) -> Optional[bytes]:
+        if vp_snapshot:
+            snapshot_path = topic_dir.joinpath(vp_snapshot)
+            if snapshot_path.exists():
+                return snapshot_path.read_bytes()
+        return None
+
+    @staticmethod
+    def _load_bitmaps(topic_dir: zipfile.Path, visinfo: Optional[mdl.VisualizationInfo]) -> dict[str, bytes]:
+        if not visinfo or not (bitmaps := visinfo.bitmaps):
+            return {}
+        bitmaps_dict = {}
+        for bitmap in bitmaps.bitmap:
+            if not bitmap.reference:
+                continue
+            bitmap_path = topic_dir.joinpath(bitmap.reference)
+            if bitmap_path.exists():
+                bitmaps_dict[bitmap.reference] = bitmap_path.read_bytes()
+        return bitmaps_dict
+
+    def save(
+        self,
+        bcf_zip: ZipFileInterface,
+        topic_dir: str,
+        vpt: mdl.ViewPoint,
+    ) -> None:
+        """
+        Save the VisualizationInfo and related objects to a BCF zip file.
+
+        Args:
+            bcf_zip: The BCF zip file to save to.
+            topic_dir: The directory in the BCF zip file to save to.
+            vpt: The ViewPoint to save.
+        """
+        if not (vp_name := vpt.viewpoint):
+            return
+        self._save_visinfo(bcf_zip, topic_dir, vp_name)
+        self._save_snapshot(bcf_zip, topic_dir, vpt.snapshot)
+        self._save_bitmaps(bcf_zip, topic_dir)
+
+    def _save_snapshot(self, bcf_zip: ZipFileInterface, topic_dir: str, filename: Optional[str]) -> None:
+        if self.snapshot and filename:
+            bcf_zip.writestr(f"{topic_dir}/{filename}", self.snapshot)
+
+    def _save_visinfo(self, bcf_zip: ZipFileInterface, topic_dir: str, vp_name: str) -> None:
+        bcf_zip.writestr(
+            f"{topic_dir}/{vp_name}",
+            self._xml_handler.serialize(self.visualization_info),
+        )
+
+    def _save_bitmaps(self, bcf_zip: ZipFileInterface, topic_dir: str) -> None:
+        if not self.bitmaps:
+            return
+        if not (bitmaps_defs := self.visualization_info.bitmaps):
+            return
+        for bitmap_def in bitmaps_defs.bitmap:
+            if not (bitmap_name := bitmap_def.reference):
+                continue
+            if bitmap_name in self.bitmaps:
+                bcf_zip.writestr(f"{topic_dir}/{bitmap_name}", self.bitmaps[bitmap_name])
+
+    @classmethod
+    def create_new(
+        cls,
+        element: entity_instance,
+        xml_handler: Optional[AbstractXmlParserSerializer] = None,
+    ) -> "VisualizationInfoHandler":
+        """
+        Create a new VisualizationInfoHandler object from an IFC element.
+
+        Args:
+            element: The IFC element to point at.
+            xml_handler: The XML handler to use.
+
+        Returns:
+            The VisualizationInfoHandler object.
+        """
+        xml_handler = xml_handler or XmlParserSerializer()
+        return cls(visualization_info=build_viewpoint(element), xml_handler=xml_handler)
+
+
+@lru_cache(maxsize=None)
+def build_viewpoint(element: entity_instance) -> mdl.VisualizationInfo:
+    """
+    Return a BCF viewpoint of an IFC element.
+
+    This function is cached to speedudp the creation of multiple BCF topics regarding the same element.
+
+    Args:
+        element: The IFC element to point at.
+
+    Returns:
+        The BCF viewpoint definition.
+    """
+    elem_placement = placement.get_local_placement(element.ObjectPlacement)
+
+    return mdl.VisualizationInfo(
+        guid=str(uuid.uuid4()),
+        components=build_components(element.GlobalId),
+        perspective_camera=build_camera(elem_placement),
+    )
+
+
+def build_components(guid: str) -> mdl.Components:
+    """
+    Return the BCF components from an IFC element GUID.
+
+    Args:
+        guid: The IFC element GUID.
+
+    Returns:
+        The BCF components definition.
+    """
+    return mdl.Components(
+        selection=mdl.ComponentSelection(component=[mdl.Component(ifc_guid=guid)]),
+        visibility=mdl.ComponentVisibility(default_visibility=True),
+    )
+
+
+def build_camera(elem_placement: NDArray[np.float_]) -> mdl.PerspectiveCamera:
+    """
+    Return a BCF camera for an IFC element placement matrix.
+
+    Args:
+        elem_placement: The IFC element placement as a rototranslation matrix.
+
+    Returns:
+        The BCF camera definition.
+    """
+    return build_camera_from_vectors(*calc_camera_vectors(elem_placement))
+
+
+def build_camera_from_vectors(
+    camera_position: NDArray[np.float_], camera_dir: NDArray[np.float_], camera_up: NDArray[np.float_]
+) -> mdl.PerspectiveCamera:
+    """
+    Return a BCF camera for an IFC element placement matrix.
+
+    Args:
+        camera_position: camera position array
+        camera_dir: camera direction versor
+        camera_up_vector: camera up versor
+
+    Returns:
+        The BCF camera definition.
+    """
+    camera_viewpoint = mdl.Point(x=camera_position[0], y=camera_position[1], z=camera_position[2])
+    camera_direction = mdl.Direction(x=camera_dir[0], y=camera_dir[1], z=camera_dir[2])
+    camera_up_vector = mdl.Direction(x=camera_up[0], y=camera_up[1], z=camera_up[2])
+    return mdl.PerspectiveCamera(
+        camera_view_point=camera_viewpoint,
+        camera_direction=camera_direction,
+        camera_up_vector=camera_up_vector,
+        aspect_ratio=1.0,
+        field_of_view=60.0,
+    )
@@ -0,0 +1,83 @@
+"""XML Parser and Serializer factories."""
+from typing import Optional, Protocol, Type, TypeVar
+
+from xsdata.formats.dataclass.context import XmlContext
+from xsdata.formats.dataclass.parsers import XmlParser
+from xsdata.formats.dataclass.serializers import XmlSerializer
+from xsdata.formats.dataclass.serializers.config import SerializerConfig
+
+
+def build_xml_parser(context: Optional[XmlContext] = None) -> XmlParser:
+    """Return a parser for an XML file."""
+    parser = XmlParser(context=context or XmlContext())
+    parser.register_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+    return parser
+
+
+def build_serializer(context: Optional[XmlContext] = None) -> XmlSerializer:
+    """Return a serializer for an XML file."""
+    return XmlSerializer(
+        config=SerializerConfig(pretty_print=True),
+        context=context or XmlContext(),
+    )
+
+
+T = TypeVar("T")
+
+
+class AbstractXmlParserSerializer(Protocol):
+    """XML Parser and serializer wrapper."""
+
+    def parse(self, xml: bytes, clazz: Type[T]) -> T:
+        """
+        Parse an XML file to an object.
+
+        Args:
+            xml: The XML file as bytes.
+            clazz: The class to parse to.
+        """
+
+    def serialize(self, obj: T, ns_map: Optional[dict[str, str]] = None) -> str:
+        """
+        Serialize an object to XML.
+
+        Args:
+            obj: The object to serialize.
+            ns_map: The namespace map to use.
+
+        Returns:
+            The XML as string.
+        """
+
+
+class XmlParserSerializer:
+    """XML Parser and serializer wrapper."""
+
+    def __init__(self) -> None:
+        self.context = XmlContext()
+        self.parser = build_xml_parser(self.context)
+        self.serializer = build_serializer(self.context)
+
+    def parse(self, xml: bytes, clazz: Type[T]) -> T:
+        """
+        Parse an XML file to an object.
+
+        Args:
+            xml: The XML file as bytes.
+            clazz: The class to parse to.
+        """
+        return self.parser.from_bytes(xml, clazz)
+
+    def serialize(self, obj: T, ns_map: Optional[dict[str, str]] = None) -> str:
+        """
+        Serialize an object to XML.
+
+        Args:
+            obj: The object to serialize.
+            ns_map: The namespace map to use.
+
+        Returns:
+            The XML as string.
+        """
+        ns_map = ns_map or {"xs": "http://www.w3.org/2001/XMLSchema"}
+        return self.serializer.render(obj, ns_map)
@@ -0,0 +1 @@
+"""BCF tests."""
@@ -0,0 +1,8 @@
+import pytest
+
+from bcf.xml_parser import XmlParserSerializer
+
+
+@pytest.fixture(scope="session")
+def xml_handler() -> XmlParserSerializer:
+    return XmlParserSerializer()
--- a/Show More
+++ b/Show More