Merge pull request #104 from google/gbg/fix-windll-load

fix libusb loading on Windows

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Migrate code style to Black
+135df0dcc01ab765f432e19b1a5202d29bd55545

.github/workflows/code-check.yml

@@ -0,0 +1,35 @@
+# Check the code against the formatter and linter
+name: Code format and lint check
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    name: Check Code
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out from Git
+      uses: actions/checkout@v3
+    - name: Get history and tags for SCM versioning to work
+      run: |
+        git fetch --prune --unshallow
+        git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ".[build,test,development]"
+    - name: Check
+      run: |
+        invoke project.pre-commit

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '39 21 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/python-build-test.yml

@@ -0,0 +1,43 @@
+# Build and test the python package
+name: Python build and test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+      fail-fast: false
+
+    steps:
+    - name: Check out from Git
+      uses: actions/checkout@v3
+    - name: Get history and tags for SCM versioning to work
+      run: |
+        git fetch --prune --unshallow
+        git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ".[build,test,development,documentation]"
+    - name: Test
+      run: |
+        invoke test
+    - name: Build
+      run: |
+        inv build
+        inv build.mkdocs

.github/workflows/python-publish.yml

@@ -0,0 +1,37 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+    
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out from Git
+      uses: actions/checkout@v3
+    - name: Get history and tags for SCM versioning to work
+      run: |
+        git fetch --prune --unshallow
+        git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package to PyPI
+      if: github.event_name == 'release' && startsWith(github.ref, 'refs/tags')
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

.gitignore

@@ -0,0 +1,11 @@
+.eggs/
+build/
+dist/
+*.egg-info/
+*~
+docs/mkdocs/site
+test-results.xml
+__pycache__
+# generated by setuptools_scm
+bumble/_version.py
+.vscode/launch.json

.vscode/settings.json

@@ -0,0 +1,75 @@
+{
+    "cSpell.words": [
+        "Abortable",
+        "altsetting",
+        "ansiblue",
+        "ansicyan",
+        "ansigreen",
+        "ansimagenta",
+        "ansired",
+        "ansiyellow",
+        "appendleft",
+        "ASHA",
+        "asyncio",
+        "ATRAC",
+        "avdtp",
+        "bitpool",
+        "bitstruct",
+        "BSCP",
+        "BTPROTO",
+        "CCCD",
+        "cccds",
+        "cmac",
+        "CONNECTIONLESS",
+        "csrcs",
+        "datagram",
+        "DATALINK",
+        "delayreport",
+        "deregisters",
+        "deregistration",
+        "dhkey",
+        "diversifier",
+        "Fitbit",
+        "GATTLINK",
+        "HANDSFREE",
+        "keydown",
+        "keyup",
+        "levelname",
+        "libc",
+        "libusb",
+        "MITM",
+        "NDIS",
+        "NONBLOCK",
+        "NONCONN",
+        "OXIMETER",
+        "popleft",
+        "psms",
+        "pyee",
+        "pyusb",
+        "rfcomm",
+        "ROHC",
+        "rssi",
+        "SEID",
+        "seids",
+        "SERV",
+        "ssrc",
+        "strerror",
+        "subband",
+        "subbands",
+        "subevent",
+        "Subrating",
+        "substates",
+        "tobytes",
+        "tsep",
+        "usbmodem",
+        "vhci",
+        "websockets",
+        "xcursor",
+        "ycursor"
+    ],
+    "[python]": {
+        "editor.rulers": [88]
+    },
+    "python.formatting.provider": "black",
+    "pylint.importStrategy": "useBundled"
+}

CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement (CLA). You (or your employer) retain the copyright to your
+contribution; this simply gives us permission to use and redistribute your
+contributions as part of the project. Head over to
+<https://cla.developers.google.com/> to see your current agreements on file or
+to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code Reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Community Guidelines
+
+This project follows
+[Google's Open Source Community Guidelines](https://opensource.google/conduct/).

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,65 @@
+
+     _                 _     _
+    | |               | |   | |
+    | |__  _   _ ____ | |__ | | _____
+    |  _ \| | | |    \|  _ \| || ___ |
+    | |_) ) |_| | | | | |_) ) || ____|
+    |____/|____/|_|_|_|____/ \_)_____)
+
+Bluetooth Stack for Apps, Emulation, Test and Experimentation
+=============================================================
+
+<img src="docs/mkdocs/src/images/logo_framed.png" alt="Logo" width="200" height="200"/>
+
+Bumble is a full-featured Bluetooth stack written entirely in Python. It supports most of the common Bluetooth Low Energy (BLE) and Bluetooth Classic (BR/EDR) protocols and profiles, including GAP, L2CAP, ATT, GATT, SMP, SDP, RFCOMM, HFP, HID and A2DP. The stack can be used with physical radios via HCI over USB, UART, or the Linux VHCI, as well as virtual radios, including the virtual Bluetooth support of the Android emulator.
+
+## Documentation
+
+Browse the pre-built [Online Documentation](https://google.github.io/bumble/),
+or see the documentation source under `docs/mkdocs/src`, or build the static HTML site from the markdown text with:
+```
+mkdocs build -f docs/mkdocs/mkdocs.yml
+```
+
+## Usage
+
+### Getting Started
+
+For a quick start to using Bumble, see the [Getting Started](docs/mkdocs/src/getting_started.md) guide.
+
+### Dependencies
+
+To install package dependencies needed to run the bumble examples, execute the following commands:
+
+```
+python -m pip install --upgrade pip
+python -m pip install ".[test,development,documentation]"
+```
+
+### Examples
+
+Refer to the [Examples Documentation](examples/README.md) for details on the included example scripts and how to run them.
+
+The complete [list of Examples](/docs/mkdocs/src/examples/index.md), and what they are designed to do is here.
+
+There are also a set of [Apps and Tools](docs/mkdocs/src/apps_and_tools/index.md) that show the utility of Bumble.
+
+### Using Bumble With a USB Dongle
+
+Bumble is easiest to use with a dedicated USB dongle.
+This is because internal Bluetooth interfaces tend to be locked down by the operating system.
+You can use the [usb_probe](/docs/mkdocs/src/apps_and_tools/usb_probe.md) tool (all platforms) or `lsusb` (Linux or macOS) to list the available USB devices on your system.
+
+See the [USB Transport](/docs/mkdocs/src/transports/usb.md) page for details on how to refer to USB devices. Also, if your are on a mac, see [these instructions](docs/mkdocs/src/platforms/macos.md).
+
+## License
+
+Licensed under the [Apache 2.0](LICENSE) License.
+
+## Disclaimer
+
+This is not an official Google product.
+
+This library is in alpha and will be going through a lot of breaking changes. While releases will be stable enough for prototyping, experimentation and research, we do not recommend using it in any production environment yet.
+Expect bugs and sharp edges.
+Please help by trying it out, reporting bugs, and letting us know what you think!

apps/README.md

@@ -0,0 +1,49 @@
+Bumble Apps
+===========
+
+NOTE:
+To run python scripts from this directory when the Bumble package isn't installed in your environment,
+put .. in your PYTHONPATH: `export PYTHONPATH=..`
+
+
+Apps
+----
+
+## `show.py`
+Parse a file with HCI packets and print the details of each packet in a human readable form
+
+## `link_relay.py`
+Simple WebSocket relay for virtual RemoteLink instances to communicate with each other through.
+
+## `hci_bridge.py`
+This app acts as a simple bridge between two HCI transports, with a host on one side and
+a controller on the other. All the HCI packets bridged between the two are printed on the console
+for logging. This bridge also has the ability to short-circuit some HCI packets (respond to them
+with a fixed response instead of bridging them to the other side), which may be useful when used with
+a host that send custom HCI commands that the controller may not understand.
+
+### Usage
+```
+python hci_bridge.py <host-transport-spec> <controller-transport-spec> [command-short-circuit-list]
+```
+
+### Examples
+
+#### UDP to HCI UART
+```
+python hci_bridge.py udp:0.0.0.0:9000,127.0.0.1:9001 serial:/dev/tty.usbmodem0006839912171,1000000 0x3f:0x0070,0x3f:0x0074,0x3f:0x0077,0x3f:0x0078
+```
+
+#### PTY to Link Relay
+```
+python hci_bridge.py serial:emulated_uart_pty,1000000 link-relay:ws://127.0.0.1:10723/test
+```
+
+In this example, an emulator that exposes a PTY as an interface to its HCI UART is running as
+a Bluetooth host, and we are connecting it to a virtual controller attached to a link relay
+(through which the communication with other virtual controllers will be mediated).
+
+NOTE: this assumes you're running a Link Relay on port `10723`.
+
+## `console.py`
+A simple text-based-ui interactive Bluetooth device with GATT client capabilities.

apps/controller_info.py

@@ -0,0 +1,162 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+from bumble.company_ids import COMPANY_IDENTIFIERS
+
+from bumble.core import name_or_number
+from bumble.hci import (
+    map_null_terminated_utf8_string,
+    HCI_SUCCESS,
+    HCI_LE_SUPPORTED_FEATURES_NAMES,
+    HCI_VERSION_NAMES,
+    LMP_VERSION_NAMES,
+    HCI_Command,
+    HCI_READ_BD_ADDR_COMMAND,
+    HCI_Read_BD_ADDR_Command,
+    HCI_READ_LOCAL_NAME_COMMAND,
+    HCI_Read_Local_Name_Command,
+    HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND,
+    HCI_LE_Read_Maximum_Data_Length_Command,
+    HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND,
+    HCI_LE_Read_Number_Of_Supported_Advertising_Sets_Command,
+    HCI_LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH_COMMAND,
+    HCI_LE_Read_Maximum_Advertising_Data_Length_Command,
+)
+from bumble.host import Host
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def get_classic_info(host):
+    if host.supports_command(HCI_READ_BD_ADDR_COMMAND):
+        response = await host.send_command(HCI_Read_BD_ADDR_Command())
+        if response.return_parameters.status == HCI_SUCCESS:
+            print()
+            print(
+                color('Classic Address:', 'yellow'), response.return_parameters.bd_addr
+            )
+
+    if host.supports_command(HCI_READ_LOCAL_NAME_COMMAND):
+        response = await host.send_command(HCI_Read_Local_Name_Command())
+        if response.return_parameters.status == HCI_SUCCESS:
+            print()
+            print(
+                color('Local Name:', 'yellow'),
+                map_null_terminated_utf8_string(response.return_parameters.local_name),
+            )
+
+
+# -----------------------------------------------------------------------------
+async def get_le_info(host):
+    print()
+
+    if host.supports_command(HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND):
+        response = await host.send_command(
+            HCI_LE_Read_Number_Of_Supported_Advertising_Sets_Command()
+        )
+        if response.return_parameters.status == HCI_SUCCESS:
+            print(
+                color('LE Number Of Supported Advertising Sets:', 'yellow'),
+                response.return_parameters.num_supported_advertising_sets,
+                '\n',
+            )
+
+    if host.supports_command(HCI_LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH_COMMAND):
+        response = await host.send_command(
+            HCI_LE_Read_Maximum_Advertising_Data_Length_Command()
+        )
+        if response.return_parameters.status == HCI_SUCCESS:
+            print(
+                color('LE Maximum Advertising Data Length:', 'yellow'),
+                response.return_parameters.max_advertising_data_length,
+                '\n',
+            )
+
+    if host.supports_command(HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND):
+        response = await host.send_command(HCI_LE_Read_Maximum_Data_Length_Command())
+        if response.return_parameters.status == HCI_SUCCESS:
+            print(
+                color('Maximum Data Length:', 'yellow'),
+                (
+                    f'tx:{response.return_parameters.supported_max_tx_octets}/'
+                    f'{response.return_parameters.supported_max_tx_time}, '
+                    f'rx:{response.return_parameters.supported_max_rx_octets}/'
+                    f'{response.return_parameters.supported_max_rx_time}'
+                ),
+                '\n',
+            )
+
+    print(color('LE Features:', 'yellow'))
+    for feature in host.supported_le_features:
+        print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
+
+
+# -----------------------------------------------------------------------------
+async def async_main(transport):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        host = Host(hci_source, hci_sink)
+        await host.reset()
+
+        # Print version
+        print(color('Version:', 'yellow'))
+        print(
+            color('  Manufacturer:  ', 'green'),
+            name_or_number(COMPANY_IDENTIFIERS, host.local_version.company_identifier),
+        )
+        print(
+            color('  HCI Version:   ', 'green'),
+            name_or_number(HCI_VERSION_NAMES, host.local_version.hci_version),
+        )
+        print(color('  HCI Subversion:', 'green'), host.local_version.hci_subversion)
+        print(
+            color('  LMP Version:   ', 'green'),
+            name_or_number(LMP_VERSION_NAMES, host.local_version.lmp_version),
+        )
+        print(color('  LMP Subversion:', 'green'), host.local_version.lmp_subversion)
+
+        # Get the Classic info
+        await get_classic_info(host)
+
+        # Get the LE info
+        await get_le_info(host)
+
+        # Print the list of commands supported by the controller
+        print()
+        print(color('Supported Commands:', 'yellow'))
+        for command in host.supported_commands:
+            print('  ', HCI_Command.command_name(command))
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.argument('transport')
+def main(transport):
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+    asyncio.run(async_main(transport))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/controllers.py

@@ -0,0 +1,71 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import asyncio
+import sys
+import os
+
+from bumble.controller import Controller
+from bumble.link import LocalLink
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def async_main():
+    if len(sys.argv) != 3:
+        print(
+            'Usage: controllers.py <hci-transport-1> <hci-transport-2> '
+            '[<hci-transport-3> ...]'
+        )
+        print('example: python controllers.py pty:ble1 pty:ble2')
+        return
+
+    # Create a local link to attach the controllers to
+    link = LocalLink()
+
+    # Create a transport and controller for all requested names
+    transports = []
+    controllers = []
+    for index, transport_name in enumerate(sys.argv[1:]):
+        transport = await open_transport_or_link(transport_name)
+        transports.append(transport)
+        controller = Controller(
+            f'C{index}',
+            host_source=transport.source,
+            host_sink=transport.sink,
+            link=link,
+        )
+        controllers.append(controller)
+
+    # Wait until the user interrupts
+    await asyncio.get_running_loop().create_future()
+
+    # Cleanup
+    for transport in transports:
+        transport.close()
+
+
+# -----------------------------------------------------------------------------
+def main():
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main())
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/gatt_dump.py

@@ -0,0 +1,117 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+
+import bumble.core
+from bumble.device import Device, Peer
+from bumble.gatt import show_services
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def dump_gatt_db(peer, done):
+    # Discover all services
+    print(color('### Discovering Services and Characteristics', 'magenta'))
+    await peer.discover_services()
+    for service in peer.services:
+        await service.discover_characteristics()
+        for characteristic in service.characteristics:
+            await characteristic.discover_descriptors()
+
+    print(color('=== Services ===', 'yellow'))
+    show_services(peer.services)
+    print()
+
+    # Discover all attributes
+    print(color('=== All Attributes ===', 'yellow'))
+    attributes = await peer.discover_attributes()
+    for attribute in attributes:
+        print(attribute)
+        try:
+            value = await attribute.read_value()
+            print(color(f'{value.hex()}', 'green'))
+        except bumble.core.ProtocolError as error:
+            print(color(error, 'red'))
+        except bumble.core.TimeoutError:
+            print(color('read timeout', 'red'))
+
+    if done is not None:
+        done.set_result(None)
+
+
+# -----------------------------------------------------------------------------
+async def async_main(device_config, encrypt, transport, address_or_name):
+    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+
+        # Create a device
+        if device_config:
+            device = Device.from_config_file_with_hci(
+                device_config, hci_source, hci_sink
+            )
+        else:
+            device = Device.with_hci(
+                'Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink
+            )
+        await device.power_on()
+
+        if address_or_name:
+            # Connect to the target peer
+            connection = await device.connect(address_or_name)
+
+            # Encrypt the connection if required
+            if encrypt:
+                await connection.encrypt()
+
+            await dump_gatt_db(Peer(connection), None)
+        else:
+            # Wait for a connection
+            done = asyncio.get_running_loop().create_future()
+            device.on(
+                'connection',
+                lambda connection: asyncio.create_task(
+                    dump_gatt_db(Peer(connection), done)
+                ),
+            )
+            await device.start_advertising(auto_restart=True)
+
+            print(color('### Waiting for connection...', 'blue'))
+            await done
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--device-config', help='Device configuration', type=click.Path())
+@click.option('--encrypt', help='Encrypt the connection', is_flag=True, default=False)
+@click.argument('transport')
+@click.argument('address-or-name', required=False)
+def main(device_config, encrypt, transport, address_or_name):
+    """
+    Dump the GATT database on a remote device. If ADDRESS_OR_NAME is not specified,
+    wait for an incoming connection.
+    """
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main(device_config, encrypt, transport, address_or_name))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/gg_bridge.py

@@ -0,0 +1,397 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import struct
+import logging
+import click
+from colors import color
+
+from bumble.device import Device, Peer
+from bumble.core import AdvertisingData
+from bumble.gatt import Service, Characteristic, CharacteristicValue
+from bumble.utils import AsyncRunner
+from bumble.transport import open_transport_or_link
+from bumble.hci import HCI_Constant
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+GG_GATTLINK_SERVICE_UUID = 'ABBAFF00-E56A-484C-B832-8B17CF6CBFE8'
+GG_GATTLINK_RX_CHARACTERISTIC_UUID = 'ABBAFF01-E56A-484C-B832-8B17CF6CBFE8'
+GG_GATTLINK_TX_CHARACTERISTIC_UUID = 'ABBAFF02-E56A-484C-B832-8B17CF6CBFE8'
+GG_GATTLINK_L2CAP_CHANNEL_PSM_CHARACTERISTIC_UUID = (
+    'ABBAFF03-E56A-484C-B832-8B17CF6CBFE8'
+)
+
+GG_PREFERRED_MTU = 256
+
+
+# -----------------------------------------------------------------------------
+class GattlinkL2capEndpoint:
+    def __init__(self):
+        self.l2cap_channel = None
+        self.l2cap_packet = b''
+        self.l2cap_packet_size = 0
+
+    # Called when an L2CAP SDU has been received
+    def on_coc_sdu(self, sdu):
+        print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
+        while len(sdu):
+            if self.l2cap_packet_size == 0:
+                # Expect a new packet
+                self.l2cap_packet_size = sdu[0] + 1
+                sdu = sdu[1:]
+            else:
+                bytes_needed = self.l2cap_packet_size - len(self.l2cap_packet)
+                chunk = min(bytes_needed, len(sdu))
+                self.l2cap_packet += sdu[:chunk]
+                sdu = sdu[chunk:]
+                if len(self.l2cap_packet) == self.l2cap_packet_size:
+                    self.on_l2cap_packet(self.l2cap_packet)
+                    self.l2cap_packet = b''
+                    self.l2cap_packet_size = 0
+
+
+# -----------------------------------------------------------------------------
+class GattlinkHubBridge(GattlinkL2capEndpoint, Device.Listener):
+    def __init__(self, device, peer_address):
+        super().__init__()
+        self.device = device
+        self.peer_address = peer_address
+        self.peer = None
+        self.tx_socket = None
+        self.rx_characteristic = None
+        self.tx_characteristic = None
+        self.l2cap_psm_characteristic = None
+
+        device.listener = self
+
+    async def start(self):
+        # Connect to the peer
+        print(f'=== Connecting to {self.peer_address}...')
+        await self.device.connect(self.peer_address)
+
+    async def connect_l2cap(self, psm):
+        print(color(f'### Connecting with L2CAP on PSM = {psm}', 'yellow'))
+        try:
+            self.l2cap_channel = await self.peer.connection.open_l2cap_channel(psm)
+            print(color('*** Connected', 'yellow'), self.l2cap_channel)
+            self.l2cap_channel.sink = self.on_coc_sdu
+
+        except Exception as error:
+            print(color(f'!!! Connection failed: {error}', 'red'))
+
+    @AsyncRunner.run_in_task()
+    # pylint: disable=invalid-overridden-method
+    async def on_connection(self, connection):
+        print(f'=== Connected to {connection}')
+        self.peer = Peer(connection)
+
+        # Request a larger MTU than the default
+        server_mtu = await self.peer.request_mtu(GG_PREFERRED_MTU)
+        print(f'### Server MTU = {server_mtu}')
+
+        # Discover all services
+        print(color('=== Discovering services', 'yellow'))
+        await self.peer.discover_service(GG_GATTLINK_SERVICE_UUID)
+        print(color('=== Services discovered', 'yellow'), self.peer.services)
+        for service in self.peer.services:
+            print(service)
+        services = self.peer.get_services_by_uuid(GG_GATTLINK_SERVICE_UUID)
+        if not services:
+            print(color('!!! Gattlink service not found', 'red'))
+            return
+
+        # Use the first Gattlink (there should only be one anyway)
+        gattlink_service = services[0]
+
+        # Discover all the characteristics for the service
+        characteristics = await gattlink_service.discover_characteristics()
+        print(color('=== Characteristics discovered', 'yellow'))
+        for characteristic in characteristics:
+            if characteristic.uuid == GG_GATTLINK_RX_CHARACTERISTIC_UUID:
+                self.rx_characteristic = characteristic
+            elif characteristic.uuid == GG_GATTLINK_TX_CHARACTERISTIC_UUID:
+                self.tx_characteristic = characteristic
+            elif (
+                characteristic.uuid == GG_GATTLINK_L2CAP_CHANNEL_PSM_CHARACTERISTIC_UUID
+            ):
+                self.l2cap_psm_characteristic = characteristic
+        print('RX:', self.rx_characteristic)
+        print('TX:', self.tx_characteristic)
+        print('PSM:', self.l2cap_psm_characteristic)
+
+        if self.l2cap_psm_characteristic:
+            # Subscribe to and then read the PSM value
+            await self.peer.subscribe(
+                self.l2cap_psm_characteristic, self.on_l2cap_psm_received
+            )
+            psm_bytes = await self.peer.read_value(self.l2cap_psm_characteristic)
+            psm = struct.unpack('<H', psm_bytes)[0]
+            await self.connect_l2cap(psm)
+        elif self.tx_characteristic:
+            # Subscribe to TX
+            await self.peer.subscribe(self.tx_characteristic, self.on_tx_received)
+            print(color('=== Subscribed to Gattlink TX', 'yellow'))
+        else:
+            print(color('!!! No Gattlink TX or PSM found', 'red'))
+
+    def on_connection_failure(self, error):
+        print(color(f'!!! Connection failed: {error}'))
+
+    def on_disconnection(self, reason):
+        print(
+            color(
+                f'!!! Disconnected from {self.peer}, '
+                f'reason={HCI_Constant.error_name(reason)}',
+                'red',
+            )
+        )
+        self.tx_characteristic = None
+        self.rx_characteristic = None
+        self.peer = None
+
+    # Called when an L2CAP packet has been received
+    def on_l2cap_packet(self, packet):
+        print(color(f'<<< [L2CAP PACKET]: {len(packet)} bytes', 'cyan'))
+        print(color('>>> [UDP]', 'magenta'))
+        self.tx_socket.sendto(packet)
+
+    # Called by the GATT client when a notification is received
+    def on_tx_received(self, value):
+        print(color(f'<<< [GATT TX]: {len(value)} bytes', 'cyan'))
+        if self.tx_socket:
+            print(color('>>> [UDP]', 'magenta'))
+            self.tx_socket.sendto(value)
+
+    # Called by asyncio when the UDP socket is created
+    def on_l2cap_psm_received(self, value):
+        psm = struct.unpack('<H', value)[0]
+        asyncio.create_task(self.connect_l2cap(psm))
+
+    # Called by asyncio when the UDP socket is created
+    def connection_made(self, transport):
+        pass
+
+    # Called by asyncio when a UDP datagram is received
+    def datagram_received(self, data, _address):
+        print(color(f'<<< [UDP]: {len(data)} bytes', 'green'))
+
+        if self.l2cap_channel:
+            print(color('>>> [L2CAP]', 'yellow'))
+            self.l2cap_channel.write(bytes([len(data) - 1]) + data)
+        elif self.peer and self.rx_characteristic:
+            print(color('>>> [GATT RX]', 'yellow'))
+            asyncio.create_task(self.peer.write_value(self.rx_characteristic, data))
+
+
+# -----------------------------------------------------------------------------
+class GattlinkNodeBridge(GattlinkL2capEndpoint, Device.Listener):
+    def __init__(self, device):
+        super().__init__()
+        self.device = device
+        self.peer = None
+        self.tx_socket = None
+        self.tx_subscriber = None
+        self.rx_characteristic = None
+        self.transport = None
+
+        # Register as a listener
+        device.listener = self
+
+        # Listen for incoming L2CAP CoC connections
+        psm = 0xFB
+        device.register_l2cap_channel_server(0xFB, self.on_coc)
+        print(f'### Listening for CoC connection on PSM {psm}')
+
+        # Setup the Gattlink service
+        self.rx_characteristic = Characteristic(
+            GG_GATTLINK_RX_CHARACTERISTIC_UUID,
+            Characteristic.WRITE_WITHOUT_RESPONSE,
+            Characteristic.WRITEABLE,
+            CharacteristicValue(write=self.on_rx_write),
+        )
+        self.tx_characteristic = Characteristic(
+            GG_GATTLINK_TX_CHARACTERISTIC_UUID,
+            Characteristic.NOTIFY,
+            Characteristic.READABLE,
+        )
+        self.tx_characteristic.on('subscription', self.on_tx_subscription)
+        self.psm_characteristic = Characteristic(
+            GG_GATTLINK_L2CAP_CHANNEL_PSM_CHARACTERISTIC_UUID,
+            Characteristic.READ | Characteristic.NOTIFY,
+            Characteristic.READABLE,
+            bytes([psm, 0]),
+        )
+        gattlink_service = Service(
+            GG_GATTLINK_SERVICE_UUID,
+            [self.rx_characteristic, self.tx_characteristic, self.psm_characteristic],
+        )
+        device.add_services([gattlink_service])
+        device.advertising_data = bytes(
+            AdvertisingData(
+                [
+                    (AdvertisingData.COMPLETE_LOCAL_NAME, bytes('Bumble GG', 'utf-8')),
+                    (
+                        AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS,
+                        bytes(
+                            reversed(bytes.fromhex('ABBAFF00E56A484CB8328B17CF6CBFE8'))
+                        ),
+                    ),
+                ]
+            )
+        )
+
+    async def start(self):
+        await self.device.start_advertising()
+
+    # Called by asyncio when the UDP socket is created
+    def connection_made(self, transport):
+        self.transport = transport
+
+    # Called by asyncio when a UDP datagram is received
+    def datagram_received(self, data, _address):
+        print(color(f'<<< [UDP]: {len(data)} bytes', 'green'))
+
+        if self.l2cap_channel:
+            print(color('>>> [L2CAP]', 'yellow'))
+            self.l2cap_channel.write(bytes([len(data) - 1]) + data)
+        elif self.tx_subscriber:
+            print(color('>>> [GATT TX]', 'yellow'))
+            self.tx_characteristic.value = data
+            asyncio.create_task(self.device.notify_subscribers(self.tx_characteristic))
+
+    # Called when a write to the RX characteristic has been received
+    def on_rx_write(self, _connection, data):
+        print(color(f'<<< [GATT RX]: {len(data)} bytes', 'cyan'))
+        print(color('>>> [UDP]', 'magenta'))
+        self.tx_socket.sendto(data)
+
+    # Called when the subscription to the TX characteristic has changed
+    def on_tx_subscription(self, peer, enabled):
+        print(
+            f'### [GATT TX] subscription from {peer}: '
+            f'{"enabled" if enabled else "disabled"}'
+        )
+        if enabled:
+            self.tx_subscriber = peer
+        else:
+            self.tx_subscriber = None
+
+    # Called when an L2CAP packet is received
+    def on_l2cap_packet(self, packet):
+        print(color(f'<<< [L2CAP PACKET]: {len(packet)} bytes', 'cyan'))
+        print(color('>>> [UDP]', 'magenta'))
+        self.tx_socket.sendto(packet)
+
+    # Called when a new connection is established
+    def on_coc(self, channel):
+        print('*** CoC Connection', channel)
+        self.l2cap_channel = channel
+        channel.sink = self.on_coc_sdu
+
+
+# -----------------------------------------------------------------------------
+async def run(
+    hci_transport,
+    device_address,
+    role_or_peer_address,
+    send_host,
+    send_port,
+    receive_host,
+    receive_port,
+):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        # Instantiate a bridge object
+        device = Device.with_hci('Bumble GG', device_address, hci_source, hci_sink)
+
+        # Instantiate a bridge object
+        if role_or_peer_address == 'node':
+            bridge = GattlinkNodeBridge(device)
+        else:
+            bridge = GattlinkHubBridge(device, role_or_peer_address)
+
+        # Create a UDP to RX bridge (receive from UDP, send to RX)
+        loop = asyncio.get_running_loop()
+        await loop.create_datagram_endpoint(
+            lambda: bridge, local_addr=(receive_host, receive_port)
+        )
+
+        # Create a UDP to TX bridge (receive from TX, send to UDP)
+        bridge.tx_socket, _ = await loop.create_datagram_endpoint(
+            # pylint: disable-next=unnecessary-lambda
+            lambda: asyncio.DatagramProtocol(),
+            remote_addr=(send_host, send_port),
+        )
+
+        await device.power_on()
+        await bridge.start()
+
+        # Wait until the source terminates
+        await hci_source.wait_for_termination()
+
+
+@click.command()
+@click.argument('hci_transport')
+@click.argument('device_address')
+@click.argument('role_or_peer_address')
+@click.option(
+    '-sh', '--send-host', type=str, default='127.0.0.1', help='UDP host to send to'
+)
+@click.option('-sp', '--send-port', type=int, default=9001, help='UDP port to send to')
+@click.option(
+    '-rh',
+    '--receive-host',
+    type=str,
+    default='127.0.0.1',
+    help='UDP host to receive on',
+)
+@click.option(
+    '-rp', '--receive-port', type=int, default=9000, help='UDP port to receive on'
+)
+def main(
+    hci_transport,
+    device_address,
+    role_or_peer_address,
+    send_host,
+    send_port,
+    receive_host,
+    receive_port,
+):
+    asyncio.run(
+        run(
+            hci_transport,
+            device_address,
+            role_or_peer_address,
+            send_host,
+            send_port,
+            receive_host,
+            receive_port,
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+if __name__ == '__main__':
+    main()

apps/hci_bridge.py

@@ -0,0 +1,109 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import asyncio
+import os
+import sys
+
+from bumble import hci, transport
+from bumble.bridge import HCI_Bridge
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Main
+# -----------------------------------------------------------------------------
+async def async_main():
+    if len(sys.argv) < 3:
+        print(
+            'Usage: hci_bridge.py <host-transport-spec> <controller-transport-spec> '
+            '[command-short-circuit-list]'
+        )
+        print(
+            'example: python hci_bridge.py udp:0.0.0.0:9000,127.0.0.1:9001 '
+            'serial:/dev/tty.usbmodem0006839912171,1000000 '
+            '0x3f:0x0070,0x3f:0x0074,0x3f:0x0077,0x3f:0x0078'
+        )
+        return
+
+    print('>>> connecting to HCI...')
+    async with await transport.open_transport_or_link(sys.argv[1]) as (
+        hci_host_source,
+        hci_host_sink,
+    ):
+        print('>>> connected')
+
+        print('>>> connecting to HCI...')
+        async with await transport.open_transport_or_link(sys.argv[2]) as (
+            hci_controller_source,
+            hci_controller_sink,
+        ):
+            print('>>> connected')
+
+            command_short_circuits = []
+            if len(sys.argv) >= 4:
+                for op_code_str in sys.argv[3].split(','):
+                    if ':' in op_code_str:
+                        ogf, ocf = op_code_str.split(':')
+                        command_short_circuits.append(
+                            hci.hci_command_op_code(int(ogf, 16), int(ocf, 16))
+                        )
+                    else:
+                        command_short_circuits.append(int(op_code_str, 16))
+
+            def host_to_controller_filter(hci_packet):
+                if (
+                    hci_packet.hci_packet_type == hci.HCI_COMMAND_PACKET
+                    and hci_packet.op_code in command_short_circuits
+                ):
+                    # Respond with a success response
+                    logger.debug('short-circuiting packet')
+                    response = hci.HCI_Command_Complete_Event(
+                        num_hci_command_packets=1,
+                        command_opcode=hci_packet.op_code,
+                        return_parameters=bytes([hci.HCI_SUCCESS]),
+                    )
+                    # Return a packet with 'respond to sender' set to True
+                    return (response.to_bytes(), True)
+
+                return None
+
+            _ = HCI_Bridge(
+                hci_host_source,
+                hci_host_sink,
+                hci_controller_source,
+                hci_controller_sink,
+                host_to_controller_filter,
+                None,
+            )
+            await asyncio.get_running_loop().create_future()
+
+
+# -----------------------------------------------------------------------------
+def main():
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main())
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/l2cap_bridge.py

@@ -0,0 +1,350 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+import os
+import click
+from colors import color
+
+from bumble.transport import open_transport_or_link
+from bumble.device import Device
+from bumble.utils import FlowControlAsyncPipe
+from bumble.hci import HCI_Constant
+
+
+# -----------------------------------------------------------------------------
+class ServerBridge:
+    """
+    L2CAP CoC server bridge: waits for a peer to connect an L2CAP CoC channel
+    on a specified PSM. When the connection is made, the bridge connects a TCP
+    socket to a remote host and bridges the data in both directions, with flow
+    control.
+    When the L2CAP CoC channel is closed, the bridge disconnects the TCP socket
+    and waits for a new L2CAP CoC channel to be connected.
+    When the TCP connection is closed by the TCP server, XXXX
+    """
+
+    def __init__(self, psm, max_credits, mtu, mps, tcp_host, tcp_port):
+        self.psm = psm
+        self.max_credits = max_credits
+        self.mtu = mtu
+        self.mps = mps
+        self.tcp_host = tcp_host
+        self.tcp_port = tcp_port
+
+    async def start(self, device):
+        # Listen for incoming L2CAP CoC connections
+        device.register_l2cap_channel_server(
+            psm=self.psm,
+            server=self.on_coc,
+            max_credits=self.max_credits,
+            mtu=self.mtu,
+            mps=self.mps,
+        )
+        print(color(f'### Listening for CoC connection on PSM {self.psm}', 'yellow'))
+
+        def on_ble_connection(connection):
+            def on_ble_disconnection(reason):
+                print(
+                    color('@@@ Bluetooth disconnection:', 'red'),
+                    HCI_Constant.error_name(reason),
+                )
+
+            print(color('@@@ Bluetooth connection:', 'green'), connection)
+            connection.on('disconnection', on_ble_disconnection)
+
+        device.on('connection', on_ble_connection)
+
+        await device.start_advertising(auto_restart=True)
+
+    # Called when a new L2CAP connection is established
+    def on_coc(self, l2cap_channel):
+        print(color('*** L2CAP channel:', 'cyan'), l2cap_channel)
+
+        class Pipe:
+            def __init__(self, bridge, l2cap_channel):
+                self.bridge = bridge
+                self.tcp_transport = None
+                self.l2cap_channel = l2cap_channel
+
+                l2cap_channel.on('close', self.on_l2cap_close)
+                l2cap_channel.sink = self.on_coc_sdu
+
+            async def connect_to_tcp(self):
+                # Connect to the TCP server
+                print(
+                    color(
+                        f'### Connecting to TCP {self.bridge.tcp_host}:'
+                        f'{self.bridge.tcp_port}...',
+                        'yellow',
+                    )
+                )
+
+                class TcpClientProtocol(asyncio.Protocol):
+                    def __init__(self, pipe):
+                        self.pipe = pipe
+
+                    def connection_lost(self, exc):
+                        print(color(f'!!! TCP connection lost: {exc}', 'red'))
+                        if self.pipe.l2cap_channel is not None:
+                            asyncio.create_task(self.pipe.l2cap_channel.disconnect())
+
+                    def data_received(self, data):
+                        print(f'<<< Received on TCP: {len(data)}')
+                        self.pipe.l2cap_channel.write(data)
+
+                try:
+                    (
+                        self.tcp_transport,
+                        _,
+                    ) = await asyncio.get_running_loop().create_connection(
+                        lambda: TcpClientProtocol(self),
+                        host=self.bridge.tcp_host,
+                        port=self.bridge.tcp_port,
+                    )
+                    print(color('### Connected', 'green'))
+                except Exception as error:
+                    print(color(f'!!! Connection failed: {error}', 'red'))
+                    await self.l2cap_channel.disconnect()
+
+            def on_l2cap_close(self):
+                self.l2cap_channel = None
+                if self.tcp_transport is not None:
+                    self.tcp_transport.close()
+
+            def on_coc_sdu(self, sdu):
+                print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
+                if self.tcp_transport is None:
+                    print(color('!!! TCP socket not open, dropping', 'red'))
+                    return
+                self.tcp_transport.write(sdu)
+
+        pipe = Pipe(self, l2cap_channel)
+
+        asyncio.create_task(pipe.connect_to_tcp())
+
+
+# -----------------------------------------------------------------------------
+class ClientBridge:
+    """
+    L2CAP CoC client bridge: connects to a BLE device, then waits for an inbound
+    TCP connection on a specified port number. When a TCP client connects, an
+    L2CAP CoC channel connection to the BLE device is established, and the data
+    is bridged in both directions, with flow control.
+    When the TCP connection is closed by the client, the L2CAP CoC channel is
+    disconnected, but the connection to the BLE device remains, ready for a new
+    TCP client to connect.
+    When the L2CAP CoC channel is closed, XXXX
+    """
+
+    READ_CHUNK_SIZE = 4096
+
+    def __init__(self, psm, max_credits, mtu, mps, address, tcp_host, tcp_port):
+        self.psm = psm
+        self.max_credits = max_credits
+        self.mtu = mtu
+        self.mps = mps
+        self.address = address
+        self.tcp_host = tcp_host
+        self.tcp_port = tcp_port
+
+    async def start(self, device):
+        print(color(f'### Connecting to {self.address}...', 'yellow'))
+        connection = await device.connect(self.address)
+        print(color('### Connected', 'green'))
+
+        # Called when the BLE connection is disconnected
+        def on_ble_disconnection(reason):
+            print(
+                color('@@@ Bluetooth disconnection:', 'red'),
+                HCI_Constant.error_name(reason),
+            )
+
+        connection.on('disconnection', on_ble_disconnection)
+
+        # Called when a TCP connection is established
+        async def on_tcp_connection(reader, writer):
+            peer_name = writer.get_extra_info('peer_name')
+            print(color(f'<<< TCP connection from {peer_name}', 'magenta'))
+
+            def on_coc_sdu(sdu):
+                print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
+                l2cap_to_tcp_pipe.write(sdu)
+
+            def on_l2cap_close():
+                print(color('*** L2CAP channel closed', 'red'))
+                l2cap_to_tcp_pipe.stop()
+                writer.close()
+
+            # Connect a new L2CAP channel
+            print(color(f'>>> Opening L2CAP channel on PSM = {self.psm}', 'yellow'))
+            try:
+                l2cap_channel = await connection.open_l2cap_channel(
+                    psm=self.psm,
+                    max_credits=self.max_credits,
+                    mtu=self.mtu,
+                    mps=self.mps,
+                )
+                print(color('*** L2CAP channel:', 'cyan'), l2cap_channel)
+            except Exception as error:
+                print(color(f'!!! Connection failed: {error}', 'red'))
+                writer.close()
+                return
+
+            l2cap_channel.sink = on_coc_sdu
+            l2cap_channel.on('close', on_l2cap_close)
+
+            # Start a flow control pipe from L2CAP to TCP
+            l2cap_to_tcp_pipe = FlowControlAsyncPipe(
+                l2cap_channel.pause_reading,
+                l2cap_channel.resume_reading,
+                writer.write,
+                writer.drain,
+            )
+            l2cap_to_tcp_pipe.start()
+
+            # Pipe data from TCP to L2CAP
+            while True:
+                try:
+                    data = await reader.read(self.READ_CHUNK_SIZE)
+
+                    if len(data) == 0:
+                        print(color('!!! End of stream', 'red'))
+                        await l2cap_channel.disconnect()
+                        return
+
+                    print(color(f'<<< [TCP DATA]: {len(data)} bytes', 'blue'))
+                    l2cap_channel.write(data)
+                    await l2cap_channel.drain()
+                except Exception as error:
+                    print(f'!!! Exception: {error}')
+                    break
+
+            writer.close()
+            print(color('~~~ Bye bye', 'magenta'))
+
+        await asyncio.start_server(
+            on_tcp_connection,
+            host=self.tcp_host if self.tcp_host != '_' else None,
+            port=self.tcp_port,
+        )
+        print(
+            color(
+                f'### Listening for TCP connections on port {self.tcp_port}', 'magenta'
+            )
+        )
+
+
+# -----------------------------------------------------------------------------
+async def run(device_config, hci_transport, bridge):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        device = Device.from_config_file_with_hci(device_config, hci_source, hci_sink)
+
+        # Let's go
+        await device.power_on()
+        await bridge.start(device)
+
+        # Wait until the transport terminates
+        await hci_source.wait_for_termination()
+
+
+# -----------------------------------------------------------------------------
+@click.group()
+@click.pass_context
+@click.option('--device-config', help='Device configuration file', required=True)
+@click.option('--hci-transport', help='HCI transport', required=True)
+@click.option('--psm', help='PSM for L2CAP CoC', type=int, default=1234)
+@click.option(
+    '--l2cap-coc-max-credits',
+    help='Maximum L2CAP CoC Credits',
+    type=click.IntRange(1, 65535),
+    default=128,
+)
+@click.option(
+    '--l2cap-coc-mtu',
+    help='L2CAP CoC MTU',
+    type=click.IntRange(23, 65535),
+    default=1022,
+)
+@click.option(
+    '--l2cap-coc-mps',
+    help='L2CAP CoC MPS',
+    type=click.IntRange(23, 65533),
+    default=1024,
+)
+def cli(
+    context,
+    device_config,
+    hci_transport,
+    psm,
+    l2cap_coc_max_credits,
+    l2cap_coc_mtu,
+    l2cap_coc_mps,
+):
+    context.ensure_object(dict)
+    context.obj['device_config'] = device_config
+    context.obj['hci_transport'] = hci_transport
+    context.obj['psm'] = psm
+    context.obj['max_credits'] = l2cap_coc_max_credits
+    context.obj['mtu'] = l2cap_coc_mtu
+    context.obj['mps'] = l2cap_coc_mps
+
+
+# -----------------------------------------------------------------------------
+@cli.command()
+@click.pass_context
+@click.option('--tcp-host', help='TCP host', default='localhost')
+@click.option('--tcp-port', help='TCP port', default=9544)
+def server(context, tcp_host, tcp_port):
+    bridge = ServerBridge(
+        context.obj['psm'],
+        context.obj['max_credits'],
+        context.obj['mtu'],
+        context.obj['mps'],
+        tcp_host,
+        tcp_port,
+    )
+    asyncio.run(run(context.obj['device_config'], context.obj['hci_transport'], bridge))
+
+
+# -----------------------------------------------------------------------------
+@cli.command()
+@click.pass_context
+@click.argument('bluetooth-address')
+@click.option('--tcp-host', help='TCP host', default='_')
+@click.option('--tcp-port', help='TCP port', default=9543)
+def client(context, bluetooth_address, tcp_host, tcp_port):
+    bridge = ClientBridge(
+        context.obj['psm'],
+        context.obj['max_credits'],
+        context.obj['mtu'],
+        context.obj['mps'],
+        bluetooth_address,
+        tcp_host,
+        tcp_port,
+    )
+    asyncio.run(run(context.obj['device_config'], context.obj['hci_transport'], bridge))
+
+
+# -----------------------------------------------------------------------------
+logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+if __name__ == '__main__':
+    cli(obj={})  # pylint: disable=no-value-for-parameter

apps/link_relay/link_relay.py

@@ -0,0 +1,288 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ----------------------------------------------------------------------------
+# Imports
+# ----------------------------------------------------------------------------
+import sys
+import logging
+import json
+import asyncio
+import argparse
+import uuid
+import os
+from urllib.parse import urlparse
+from colors import color
+import websockets
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# ----------------------------------------------------------------------------
+# Constants
+# ----------------------------------------------------------------------------
+DEFAULT_RELAY_PORT = 10723
+
+
+# ----------------------------------------------------------------------------
+# Utils
+# ----------------------------------------------------------------------------
+def error_to_json(error):
+    return json.dumps({'error': error})
+
+
+def error_to_result(error):
+    return f'result:{error_to_json(error)}'
+
+
+async def broadcast_message(message, connections):
+    # Send to all the connections
+    tasks = [connection.send_message(message) for connection in connections]
+    if tasks:
+        await asyncio.gather(*tasks)
+
+
+# ----------------------------------------------------------------------------
+# Connection class
+# ----------------------------------------------------------------------------
+class Connection:
+    """
+    A Connection represents a client connected to the relay over a websocket
+    """
+
+    def __init__(self, room, websocket):
+        self.room = room
+        self.websocket = websocket
+        self.address = str(uuid.uuid4())
+
+    async def send_message(self, message):
+        try:
+            logger.debug(color(f'->{self.address}: {message}', 'yellow'))
+            return await self.websocket.send(message)
+        except websockets.exceptions.WebSocketException as error:
+            logger.info(f'! client "{self}" disconnected: {error}')
+            await self.cleanup()
+
+    async def send_error(self, error):
+        return await self.send_message(f'result:{error_to_json(error)}')
+
+    async def receive_message(self):
+        try:
+            message = await self.websocket.recv()
+            logger.debug(color(f'<-{self.address}: {message}', 'blue'))
+            return message
+        except websockets.exceptions.WebSocketException as error:
+            logger.info(color(f'! client "{self}" disconnected: {error}', 'red'))
+            await self.cleanup()
+
+    async def cleanup(self):
+        if self.room:
+            await self.room.remove_connection(self)
+
+    def set_address(self, address):
+        logger.info(f'Connection address changed: {self.address} -> {address}')
+        self.address = address
+
+    def __str__(self):
+        return (
+            f'Connection(address="{self.address}", '
+            f'client={self.websocket.remote_address[0]}:'
+            f'{self.websocket.remote_address[1]})'
+        )
+
+
+# ----------------------------------------------------------------------------
+# Room class
+# ----------------------------------------------------------------------------
+class Room:
+    """
+    A Room is a collection of bridged connections
+    """
+
+    def __init__(self, relay, name):
+        self.relay = relay
+        self.name = name
+        self.observers = []
+        self.connections = []
+
+    async def add_connection(self, connection):
+        logger.info(f'New participant in {self.name}: {connection}')
+        self.connections.append(connection)
+        await self.broadcast_message(connection, f'joined:{connection.address}')
+
+    async def remove_connection(self, connection):
+        if connection in self.connections:
+            self.connections.remove(connection)
+            await self.broadcast_message(connection, f'left:{connection.address}')
+
+    def find_connections_by_address(self, address):
+        return [c for c in self.connections if c.address == address]
+
+    async def bridge_connection(self, connection):
+        while True:
+            # Wait for a message
+            message = await connection.receive_message()
+
+            # Skip empty messages
+            if message is None:
+                return
+
+            # Parse the message to decide how to handle it
+            if message.startswith('@'):
+                # This is a targeted message
+                await self.on_targeted_message(connection, message)
+            elif message.startswith('/'):
+                # This is an RPC request
+                await self.on_rpc_request(connection, message)
+            else:
+                await connection.send_message(
+                    f'result:{error_to_json("error: invalid message")}'
+                )
+
+    async def broadcast_message(self, sender, message):
+        '''
+        Send to all connections in the room except back to the sender
+        '''
+        await broadcast_message(message, [c for c in self.connections if c != sender])
+
+    async def on_rpc_request(self, connection, message):
+        command, *params = message.split(' ', 1)
+        if handler := getattr(
+            self, f'on_{command[1:].lower().replace("-","_")}_command', None
+        ):
+            try:
+                result = await handler(connection, params)
+            except Exception as error:
+                result = error_to_result(error)
+        else:
+            result = error_to_result('unknown command')
+
+        await connection.send_message(result or 'result:{}')
+
+    async def on_targeted_message(self, connection, message):
+        target, *payload = message.split(' ', 1)
+        if not payload:
+            return error_to_json('missing arguments')
+        payload = payload[0]
+        target = target[1:]
+
+        # Determine what targets to send to
+        if target == '*':
+            # Send to all connections in the room except the connection from which the
+            # message was received
+            connections = [c for c in self.connections if c != connection]
+        else:
+            connections = self.find_connections_by_address(target)
+            if not connections:
+                # Unicast with no recipient, let the sender know
+                await connection.send_message(f'unreachable:{target}')
+
+        # Send to targets
+        await broadcast_message(f'message:{connection.address}/{payload}', connections)
+
+    async def on_set_address_command(self, connection, params):
+        if not params:
+            return error_to_result('missing address')
+
+        current_address = connection.address
+        new_address = params[0]
+        connection.set_address(new_address)
+        await self.broadcast_message(
+            connection, f'address-changed:from={current_address},to={new_address}'
+        )
+
+
+# ----------------------------------------------------------------------------
+class Relay:
+    """
+    A relay accepts connections with the following url: ws://<hostname>/<room>.
+    Participants in a room can communicate with each other
+    """
+
+    def __init__(self, port):
+        self.port = port
+        self.rooms = {}
+        self.observers = []
+
+    def start(self):
+        logger.info(f'Starting Relay on port {self.port}')
+
+        # pylint: disable-next=no-member
+        return websockets.serve(self.serve, '0.0.0.0', self.port, ping_interval=None)
+
+    async def serve_as_controller(self, connection):
+        pass
+
+    async def serve(self, websocket, path):
+        logger.debug(f'New connection with path {path}')
+
+        # Parse the path
+        parsed = urlparse(path)
+
+        # Check if this is a controller client
+        if parsed.path == '/':
+            return await self.serve_as_controller(Connection('', websocket))
+
+        # Find or create a room for this connection
+        room_name = parsed.path[1:].split('/')[0]
+        if room_name not in self.rooms:
+            self.rooms[room_name] = Room(self, room_name)
+        room = self.rooms[room_name]
+
+        # Add the connection to the room
+        connection = Connection(room, websocket)
+        await room.add_connection(connection)
+
+        # Bridge until the connection is closed
+        await room.bridge_connection(connection)
+
+
+# ----------------------------------------------------------------------------
+def main():
+    # Check the Python version
+    if sys.version_info < (3, 6, 1):
+        print('ERROR: Python 3.6.1 or higher is required')
+        sys.exit(1)
+
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+
+    # Parse arguments
+    arg_parser = argparse.ArgumentParser(description='Bumble Link Relay')
+    arg_parser.add_argument('--log-level', default='INFO', help='logger level')
+    arg_parser.add_argument('--log-config', help='logger config file (YAML)')
+    arg_parser.add_argument(
+        '--port', type=int, default=DEFAULT_RELAY_PORT, help='Port to listen on'
+    )
+    args = arg_parser.parse_args()
+
+    # Setup logger
+    if args.log_config:
+        from logging import config  # pylint: disable=import-outside-toplevel
+
+        config.fileConfig(args.log_config)
+    else:
+        logging.basicConfig(level=getattr(logging, args.log_level.upper()))
+
+    # Start a relay
+    relay = Relay(args.port)
+    asyncio.get_event_loop().run_until_complete(relay.start())
+    asyncio.get_event_loop().run_forever()
+
+
+# ----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/link_relay/logging.yml

@@ -0,0 +1,21 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=stream_handler
+
+[formatters]
+keys=formatter
+
+[logger_root]
+level=DEBUG
+handlers=stream_handler
+
+[handler_stream_handler]
+class=StreamHandler
+level=DEBUG
+formatter=formatter
+args=(sys.stderr,)
+
+[formatter_formatter]
+format=%(asctime)s %(name)-12s %(levelname)-8s %(message)s

apps/pair.py

@@ -0,0 +1,408 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+import aioconsole
+from colors import color
+
+from bumble.device import Device, Peer
+from bumble.transport import open_transport_or_link
+from bumble.smp import PairingDelegate, PairingConfig
+from bumble.smp import error_name as smp_error_name
+from bumble.keys import JsonKeyStore
+from bumble.core import ProtocolError
+from bumble.gatt import (
+    GATT_DEVICE_NAME_CHARACTERISTIC,
+    GATT_GENERIC_ACCESS_SERVICE,
+    Service,
+    Characteristic,
+    CharacteristicValue,
+)
+from bumble.att import (
+    ATT_Error,
+    ATT_INSUFFICIENT_AUTHENTICATION_ERROR,
+    ATT_INSUFFICIENT_ENCRYPTION_ERROR,
+)
+
+
+# -----------------------------------------------------------------------------
+class Delegate(PairingDelegate):
+    def __init__(self, mode, connection, capability_string, prompt):
+        super().__init__(
+            {
+                'keyboard': PairingDelegate.KEYBOARD_INPUT_ONLY,
+                'display': PairingDelegate.DISPLAY_OUTPUT_ONLY,
+                'display+keyboard': PairingDelegate.DISPLAY_OUTPUT_AND_KEYBOARD_INPUT,
+                'display+yes/no': PairingDelegate.DISPLAY_OUTPUT_AND_YES_NO_INPUT,
+                'none': PairingDelegate.NO_OUTPUT_NO_INPUT,
+            }[capability_string.lower()]
+        )
+
+        self.mode = mode
+        self.peer = Peer(connection)
+        self.peer_name = None
+        self.prompt = prompt
+
+    async def update_peer_name(self):
+        if self.peer_name is not None:
+            # We already asked the peer
+            return
+
+        # Try to get the peer's name
+        if self.peer:
+            peer_name = await get_peer_name(self.peer, self.mode)
+            self.peer_name = f'{peer_name or ""} [{self.peer.connection.peer_address}]'
+        else:
+            self.peer_name = '[?]'
+
+    async def accept(self):
+        if self.prompt:
+            await self.update_peer_name()
+
+            # Wait a bit to allow some of the log lines to print before we prompt
+            await asyncio.sleep(1)
+
+            # Prompt for acceptance
+            print(color('###-----------------------------------', 'yellow'))
+            print(color(f'### Pairing request from {self.peer_name}', 'yellow'))
+            print(color('###-----------------------------------', 'yellow'))
+            while True:
+                response = await aioconsole.ainput(color('>>> Accept? ', 'yellow'))
+                response = response.lower().strip()
+
+                if response == 'yes':
+                    return True
+
+                if response == 'no':
+                    return False
+
+        # Accept silently
+        return True
+
+    async def compare_numbers(self, number, digits=6):
+        await self.update_peer_name()
+
+        # Wait a bit to allow some of the log lines to print before we prompt
+        await asyncio.sleep(1)
+
+        # Prompt for a numeric comparison
+        print(color('###-----------------------------------', 'yellow'))
+        print(color(f'### Pairing with {self.peer_name}', 'yellow'))
+        print(color('###-----------------------------------', 'yellow'))
+        while True:
+            response = await aioconsole.ainput(
+                color(
+                    f'>>> Does the other device display {number:0{digits}}? ', 'yellow'
+                )
+            )
+            response = response.lower().strip()
+
+            if response == 'yes':
+                return True
+
+            if response == 'no':
+                return False
+
+    async def get_number(self):
+        await self.update_peer_name()
+
+        # Wait a bit to allow some of the log lines to print before we prompt
+        await asyncio.sleep(1)
+
+        # Prompt for a PIN
+        while True:
+            try:
+                print(color('###-----------------------------------', 'yellow'))
+                print(color(f'### Pairing with {self.peer_name}', 'yellow'))
+                print(color('###-----------------------------------', 'yellow'))
+                return int(await aioconsole.ainput(color('>>> Enter PIN: ', 'yellow')))
+            except ValueError:
+                pass
+
+    async def display_number(self, number, digits=6):
+        await self.update_peer_name()
+
+        # Wait a bit to allow some of the log lines to print before we prompt
+        await asyncio.sleep(1)
+
+        # Display a PIN code
+        print(color('###-----------------------------------', 'yellow'))
+        print(color(f'### Pairing with {self.peer_name}', 'yellow'))
+        print(color(f'### PIN: {number:0{digits}}', 'yellow'))
+        print(color('###-----------------------------------', 'yellow'))
+
+
+# -----------------------------------------------------------------------------
+async def get_peer_name(peer, mode):
+    if mode == 'classic':
+        return await peer.request_name()
+
+    # Try to get the peer name from GATT
+    services = await peer.discover_service(GATT_GENERIC_ACCESS_SERVICE)
+    if not services:
+        return None
+
+    values = await peer.read_characteristics_by_uuid(
+        GATT_DEVICE_NAME_CHARACTERISTIC, services[0]
+    )
+    if values:
+        return values[0].decode('utf-8')
+
+    return None
+
+
+# -----------------------------------------------------------------------------
+AUTHENTICATION_ERROR_RETURNED = [False, False]
+
+
+def read_with_error(connection):
+    if not connection.is_encrypted:
+        raise ATT_Error(ATT_INSUFFICIENT_ENCRYPTION_ERROR)
+
+    if AUTHENTICATION_ERROR_RETURNED[0]:
+        return bytes([1])
+
+    AUTHENTICATION_ERROR_RETURNED[0] = True
+    raise ATT_Error(ATT_INSUFFICIENT_AUTHENTICATION_ERROR)
+
+
+def write_with_error(connection, _value):
+    if not connection.is_encrypted:
+        raise ATT_Error(ATT_INSUFFICIENT_ENCRYPTION_ERROR)
+
+    if not AUTHENTICATION_ERROR_RETURNED[1]:
+        AUTHENTICATION_ERROR_RETURNED[1] = True
+        raise ATT_Error(ATT_INSUFFICIENT_AUTHENTICATION_ERROR)
+
+
+# -----------------------------------------------------------------------------
+def on_connection(connection, request):
+    print(color(f'<<< Connection: {connection}', 'green'))
+
+    # Listen for pairing events
+    connection.on('pairing_start', on_pairing_start)
+    connection.on('pairing', on_pairing)
+    connection.on('pairing_failure', on_pairing_failure)
+
+    # Listen for encryption changes
+    connection.on(
+        'connection_encryption_change',
+        lambda: on_connection_encryption_change(connection),
+    )
+
+    # Request pairing if needed
+    if request:
+        print(color('>>> Requesting pairing', 'green'))
+        connection.request_pairing()
+
+
+# -----------------------------------------------------------------------------
+def on_connection_encryption_change(connection):
+    print(color('@@@-----------------------------------', 'blue'))
+    print(
+        color(
+            f'@@@ Connection is {"" if connection.is_encrypted else "not"}encrypted',
+            'blue',
+        )
+    )
+    print(color('@@@-----------------------------------', 'blue'))
+
+
+# -----------------------------------------------------------------------------
+def on_pairing_start():
+    print(color('***-----------------------------------', 'magenta'))
+    print(color('*** Pairing starting', 'magenta'))
+    print(color('***-----------------------------------', 'magenta'))
+
+
+# -----------------------------------------------------------------------------
+def on_pairing(keys):
+    print(color('***-----------------------------------', 'cyan'))
+    print(color('*** Paired!', 'cyan'))
+    keys.print(prefix=color('*** ', 'cyan'))
+    print(color('***-----------------------------------', 'cyan'))
+
+
+# -----------------------------------------------------------------------------
+def on_pairing_failure(reason):
+    print(color('***-----------------------------------', 'red'))
+    print(color(f'*** Pairing failed: {smp_error_name(reason)}', 'red'))
+    print(color('***-----------------------------------', 'red'))
+
+
+# -----------------------------------------------------------------------------
+async def pair(
+    mode,
+    sc,
+    mitm,
+    bond,
+    io,
+    prompt,
+    request,
+    print_keys,
+    keystore_file,
+    device_config,
+    hci_transport,
+    address_or_name,
+):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        # Create a device to manage the host
+        device = Device.from_config_file_with_hci(device_config, hci_source, hci_sink)
+
+        # Set a custom keystore if specified on the command line
+        if keystore_file:
+            device.keystore = JsonKeyStore(namespace=None, filename=keystore_file)
+
+        # Print the existing keys before pairing
+        if print_keys and device.keystore:
+            print(color('@@@-----------------------------------', 'blue'))
+            print(color('@@@ Pairing Keys:', 'blue'))
+            await device.keystore.print(prefix=color('@@@ ', 'blue'))
+            print(color('@@@-----------------------------------', 'blue'))
+
+        # Expose a GATT characteristic that can be used to trigger pairing by
+        # responding with an authentication error when read
+        if mode == 'le':
+            device.add_service(
+                Service(
+                    '50DB505C-8AC4-4738-8448-3B1D9CC09CC5',
+                    [
+                        Characteristic(
+                            '552957FB-CF1F-4A31-9535-E78847E1A714',
+                            Characteristic.READ | Characteristic.WRITE,
+                            Characteristic.READABLE | Characteristic.WRITEABLE,
+                            CharacteristicValue(
+                                read=read_with_error, write=write_with_error
+                            ),
+                        )
+                    ],
+                )
+            )
+
+        # Select LE or Classic
+        if mode == 'classic':
+            device.classic_enabled = True
+            device.le_enabled = False
+
+        # Get things going
+        await device.power_on()
+
+        # Set up a pairing config factory
+        device.pairing_config_factory = lambda connection: PairingConfig(
+            sc, mitm, bond, Delegate(mode, connection, io, prompt)
+        )
+
+        # Connect to a peer or wait for a connection
+        device.on('connection', lambda connection: on_connection(connection, request))
+        if address_or_name is not None:
+            print(color(f'=== Connecting to {address_or_name}...', 'green'))
+            connection = await device.connect(address_or_name)
+
+            if not request:
+                try:
+                    if mode == 'le':
+                        await connection.pair()
+                    else:
+                        await connection.authenticate()
+                    return
+                except ProtocolError as error:
+                    print(color(f'Pairing failed: {error}', 'red'))
+                    return
+        else:
+            # Advertise so that peers can find us and connect
+            await device.start_advertising(auto_restart=True)
+
+        await hci_source.wait_for_termination()
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option(
+    '--mode', type=click.Choice(['le', 'classic']), default='le', show_default=True
+)
+@click.option(
+    '--sc',
+    type=bool,
+    default=True,
+    help='Use the Secure Connections protocol',
+    show_default=True,
+)
+@click.option(
+    '--mitm', type=bool, default=True, help='Request MITM protection', show_default=True
+)
+@click.option(
+    '--bond', type=bool, default=True, help='Enable bonding', show_default=True
+)
+@click.option(
+    '--io',
+    type=click.Choice(
+        ['keyboard', 'display', 'display+keyboard', 'display+yes/no', 'none']
+    ),
+    default='display+keyboard',
+    show_default=True,
+)
+@click.option('--prompt', is_flag=True, help='Prompt to accept/reject pairing request')
+@click.option(
+    '--request', is_flag=True, help='Request that the connecting peer initiate pairing'
+)
+@click.option('--print-keys', is_flag=True, help='Print the bond keys before pairing')
+@click.option('--keystore-file', help='File in which to store the pairing keys')
+@click.argument('device-config')
+@click.argument('hci_transport')
+@click.argument('address-or-name', required=False)
+def main(
+    mode,
+    sc,
+    mitm,
+    bond,
+    io,
+    prompt,
+    request,
+    print_keys,
+    keystore_file,
+    device_config,
+    hci_transport,
+    address_or_name,
+):
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(
+        pair(
+            mode,
+            sc,
+            mitm,
+            bond,
+            io,
+            prompt,
+            request,
+            print_keys,
+            keystore_file,
+            device_config,
+            hci_transport,
+            address_or_name,
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/scan.py

@@ -0,0 +1,225 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+
+from bumble.device import Device
+from bumble.transport import open_transport_or_link
+from bumble.keys import JsonKeyStore
+from bumble.smp import AddressResolver
+from bumble.device import Advertisement
+from bumble.hci import HCI_Constant, HCI_LE_1M_PHY, HCI_LE_CODED_PHY
+
+
+# -----------------------------------------------------------------------------
+def make_rssi_bar(rssi):
+    DISPLAY_MIN_RSSI = -105
+    DISPLAY_MAX_RSSI = -30
+    DEFAULT_RSSI_BAR_WIDTH = 30
+
+    blocks = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']
+    bar_width = (rssi - DISPLAY_MIN_RSSI) / (DISPLAY_MAX_RSSI - DISPLAY_MIN_RSSI)
+    bar_width = min(max(bar_width, 0), 1)
+    bar_ticks = int(bar_width * DEFAULT_RSSI_BAR_WIDTH * 8)
+    return ('█' * int(bar_ticks / 8)) + blocks[bar_ticks % 8]
+
+
+# -----------------------------------------------------------------------------
+class AdvertisementPrinter:
+    def __init__(self, min_rssi, resolver):
+        self.min_rssi = min_rssi
+        self.resolver = resolver
+
+    def print_advertisement(self, advertisement):
+        address = advertisement.address
+        address_color = 'yellow' if advertisement.is_connectable else 'red'
+
+        if self.min_rssi is not None and advertisement.rssi < self.min_rssi:
+            return
+
+        address_qualifier = ''
+        resolution_qualifier = ''
+        if self.resolver and advertisement.address.is_resolvable:
+            resolved = self.resolver.resolve(advertisement.address)
+            if resolved is not None:
+                resolution_qualifier = f'(resolved from {advertisement.address})'
+                address = resolved
+
+        address_type_string = ('PUBLIC', 'RANDOM', 'PUBLIC_ID', 'RANDOM_ID')[
+            address.address_type
+        ]
+        if address.is_public:
+            type_color = 'cyan'
+        else:
+            if address.is_static:
+                type_color = 'green'
+                address_qualifier = '(static)'
+            elif address.is_resolvable:
+                type_color = 'magenta'
+                address_qualifier = '(resolvable)'
+            else:
+                type_color = 'blue'
+                address_qualifier = '(non-resolvable)'
+
+        separator = '\n  '
+        rssi_bar = make_rssi_bar(advertisement.rssi)
+        if not advertisement.is_legacy:
+            phy_info = (
+                f'PHY: {HCI_Constant.le_phy_name(advertisement.primary_phy)}/'
+                f'{HCI_Constant.le_phy_name(advertisement.secondary_phy)} '
+                f'{separator}'
+            )
+        else:
+            phy_info = ''
+
+        print(
+            f'>>> {color(address, address_color)} '
+            f'[{color(address_type_string, type_color)}]{address_qualifier}'
+            f'{resolution_qualifier}:{separator}'
+            f'{phy_info}'
+            f'RSSI:{advertisement.rssi:4} {rssi_bar}{separator}'
+            f'{advertisement.data.to_string(separator)}\n'
+        )
+
+    def on_advertisement(self, advertisement):
+        self.print_advertisement(advertisement)
+
+    def on_advertising_report(self, report):
+        print(f'{color("EVENT", "green")}: {report.event_type_string()}')
+        self.print_advertisement(Advertisement.from_advertising_report(report))
+
+
+# -----------------------------------------------------------------------------
+async def scan(
+    min_rssi,
+    passive,
+    scan_interval,
+    scan_window,
+    phy,
+    filter_duplicates,
+    raw,
+    keystore_file,
+    device_config,
+    transport,
+):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        if device_config:
+            device = Device.from_config_file_with_hci(
+                device_config, hci_source, hci_sink
+            )
+        else:
+            device = Device.with_hci(
+                'Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink
+            )
+
+        if keystore_file:
+            keystore = JsonKeyStore(namespace=None, filename=keystore_file)
+            device.keystore = keystore
+        else:
+            resolver = None
+
+        if device.keystore:
+            resolving_keys = await device.keystore.get_resolving_keys()
+            resolver = AddressResolver(resolving_keys)
+
+        printer = AdvertisementPrinter(min_rssi, resolver)
+        if raw:
+            device.host.on('advertising_report', printer.on_advertising_report)
+        else:
+            device.on('advertisement', printer.on_advertisement)
+
+        await device.power_on()
+
+        if phy is None:
+            scanning_phys = [HCI_LE_1M_PHY, HCI_LE_CODED_PHY]
+        else:
+            scanning_phys = [{'1m': HCI_LE_1M_PHY, 'coded': HCI_LE_CODED_PHY}[phy]]
+
+        await device.start_scanning(
+            active=(not passive),
+            scan_interval=scan_interval,
+            scan_window=scan_window,
+            filter_duplicates=filter_duplicates,
+            scanning_phys=scanning_phys,
+        )
+
+        await hci_source.wait_for_termination()
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--min-rssi', type=int, help='Minimum RSSI value')
+@click.option('--passive', is_flag=True, default=False, help='Perform passive scanning')
+@click.option('--scan-interval', type=int, default=60, help='Scan interval')
+@click.option('--scan-window', type=int, default=60, help='Scan window')
+@click.option(
+    '--phy', type=click.Choice(['1m', 'coded']), help='Only scan on the specified PHY'
+)
+@click.option(
+    '--filter-duplicates',
+    type=bool,
+    default=True,
+    help='Filter duplicates at the controller level',
+)
+@click.option(
+    '--raw',
+    is_flag=True,
+    default=False,
+    help='Listen for raw advertising reports instead of processed ones',
+)
+@click.option('--keystore-file', help='Keystore file to use when resolving addresses')
+@click.option('--device-config', help='Device config file for the scanning device')
+@click.argument('transport')
+def main(
+    min_rssi,
+    passive,
+    scan_interval,
+    scan_window,
+    phy,
+    filter_duplicates,
+    raw,
+    keystore_file,
+    device_config,
+    transport,
+):
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+    asyncio.run(
+        scan(
+            min_rssi,
+            passive,
+            scan_interval,
+            scan_window,
+            phy,
+            filter_duplicates,
+            raw,
+            keystore_file,
+            device_config,
+            transport,
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/show.py

@@ -0,0 +1,134 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+import click
+from colors import color
+
+from bumble import hci
+from bumble.transport.common import PacketReader
+from bumble.helpers import PacketTracer
+
+
+# -----------------------------------------------------------------------------
+class SnoopPacketReader:
+    '''
+    Reader that reads HCI packets from a "snoop" file (based on RFC 1761, but not
+    exactly the same...)
+    '''
+
+    DATALINK_H1 = 1001
+    DATALINK_H4 = 1002
+    DATALINK_BSCP = 1003
+    DATALINK_H5 = 1004
+
+    def __init__(self, source):
+        self.source = source
+
+        # Read the header
+        identification_pattern = source.read(8)
+        if identification_pattern.hex().lower() != '6274736e6f6f7000':
+            raise ValueError(
+                'not a valid snoop file, unexpected identification pattern'
+            )
+        (self.version_number, self.data_link_type) = struct.unpack(
+            '>II', source.read(8)
+        )
+        if self.data_link_type not in (self.DATALINK_H4, self.DATALINK_H1):
+            raise ValueError(f'datalink type {self.data_link_type} not supported')
+
+    def next_packet(self):
+        # Read the record header
+        header = self.source.read(24)
+        if len(header) < 24:
+            return (0, None)
+        (
+            original_length,
+            included_length,
+            packet_flags,
+            _cumulative_drops,
+            _timestamp_seconds,
+            _timestamp_microsecond,
+        ) = struct.unpack('>IIIIII', header)
+
+        # Abort on truncated packets
+        if original_length != included_length:
+            return (0, None)
+
+        if self.data_link_type == self.DATALINK_H1:
+            # The packet is un-encapsulated, look at the flags to figure out its type
+            if packet_flags & 1:
+                # Controller -> Host
+                if packet_flags & 2:
+                    packet_type = hci.HCI_EVENT_PACKET
+                else:
+                    packet_type = hci.HCI_ACL_DATA_PACKET
+            else:
+                # Host -> Controller
+                if packet_flags & 2:
+                    packet_type = hci.HCI_COMMAND_PACKET
+                else:
+                    packet_type = hci.HCI_ACL_DATA_PACKET
+
+            return (
+                packet_flags & 1,
+                bytes([packet_type]) + self.source.read(included_length),
+            )
+
+        return (packet_flags & 1, self.source.read(included_length))
+
+
+# -----------------------------------------------------------------------------
+# Main
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option(
+    '--format',
+    type=click.Choice(['h4', 'snoop']),
+    default='h4',
+    help='Format of the input file',
+)
+@click.argument('filename')
+# pylint: disable=redefined-builtin
+def main(format, filename):
+    input = open(filename, 'rb')
+    if format == 'h4':
+        packet_reader = PacketReader(input)
+
+        def read_next_packet():
+            return (0, packet_reader.next_packet())
+
+    else:
+        packet_reader = SnoopPacketReader(input)
+        read_next_packet = packet_reader.next_packet
+
+    tracer = PacketTracer(emit_message=print)
+
+    while True:
+        try:
+            (direction, packet) = read_next_packet()
+            if packet is None:
+                break
+            tracer.trace(hci.HCI_Packet.from_bytes(packet), direction)
+
+        except Exception as error:
+            print(color(f'!!! {error}', 'red'))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()  # pylint: disable=no-value-for-parameter

apps/unbond.py

@@ -0,0 +1,63 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+
+from bumble.device import Device
+from bumble.keys import JsonKeyStore
+
+
+# -----------------------------------------------------------------------------
+async def unbond(keystore_file, device_config, address):
+    # Create a device to manage the host
+    device = Device.from_config_file(device_config)
+
+    # Get all entries in the keystore
+    if keystore_file:
+        keystore = JsonKeyStore(None, keystore_file)
+    else:
+        keystore = device.keystore
+
+    if keystore is None:
+        print('no keystore')
+        return
+
+    if address is None:
+        await keystore.print()
+    else:
+        try:
+            await keystore.delete(address)
+        except KeyError:
+            print('!!! pairing not found')
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--keystore-file', help='File in which to store the pairing keys')
+@click.argument('device-config')
+@click.argument('address', required=False)
+def main(keystore_file, device_config, address):
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(unbond(keystore_file, device_config, address))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/usb_probe.py

@@ -0,0 +1,278 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# This tool lists all the USB devices, with details about each device.
+# For each device, the different possible Bumble transport strings that can
+# refer to it are listed. If the device is known to be a Bluetooth HCI device,
+# its identifier is printed in reverse colors, and the transport names in cyan color.
+# For other devices, regardless of their type, the transport names are printed
+# in red. Whether that device is actually a Bluetooth device or not depends on
+# whether it is a Bluetooth device that uses a non-standard Class, or some other
+# type of device (there's no way to tell).
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import os
+import logging
+import click
+import usb1
+from colors import color
+
+from bumble.transport.usb import load_libusb
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+USB_DEVICE_CLASS_DEVICE = 0x00
+USB_DEVICE_CLASS_WIRELESS_CONTROLLER = 0xE0
+USB_DEVICE_SUBCLASS_RF_CONTROLLER = 0x01
+USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER = 0x01
+
+USB_DEVICE_CLASSES = {
+    0x00: 'Device',
+    0x01: 'Audio',
+    0x02: 'Communications and CDC Control',
+    0x03: 'Human Interface Device',
+    0x05: 'Physical',
+    0x06: 'Still Imaging',
+    0x07: 'Printer',
+    0x08: 'Mass Storage',
+    0x09: 'Hub',
+    0x0A: 'CDC Data',
+    0x0B: 'Smart Card',
+    0x0D: 'Content Security',
+    0x0E: 'Video',
+    0x0F: 'Personal Healthcare',
+    0x10: 'Audio/Video',
+    0x11: 'Billboard',
+    0x12: 'USB Type-C Bridge',
+    0x3C: 'I3C',
+    0xDC: 'Diagnostic',
+    USB_DEVICE_CLASS_WIRELESS_CONTROLLER: (
+        'Wireless Controller',
+        {
+            0x01: {
+                0x01: 'Bluetooth',
+                0x02: 'UWB',
+                0x03: 'Remote NDIS',
+                0x04: 'Bluetooth AMP',
+            }
+        },
+    ),
+    0xEF: 'Miscellaneous',
+    0xFE: 'Application Specific',
+    0xFF: 'Vendor Specific',
+}
+
+USB_ENDPOINT_IN = 0x80
+USB_ENDPOINT_TYPES = ['CONTROL', 'ISOCHRONOUS', 'BULK', 'INTERRUPT']
+
+USB_BT_HCI_CLASS_TUPLE = (
+    USB_DEVICE_CLASS_WIRELESS_CONTROLLER,
+    USB_DEVICE_SUBCLASS_RF_CONTROLLER,
+    USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER,
+)
+
+
+# -----------------------------------------------------------------------------
+def show_device_details(device):
+    for configuration in device:
+        print(f'  Configuration {configuration.getConfigurationValue()}')
+        for interface in configuration:
+            for setting in interface:
+                alternate_setting = setting.getAlternateSetting()
+                suffix = (
+                    f'/{alternate_setting}' if interface.getNumSettings() > 1 else ''
+                )
+                (class_string, subclass_string) = get_class_info(
+                    setting.getClass(), setting.getSubClass(), setting.getProtocol()
+                )
+                details = f'({class_string}, {subclass_string})'
+                print(f'      Interface: {setting.getNumber()}{suffix} {details}')
+                for endpoint in setting:
+                    endpoint_type = USB_ENDPOINT_TYPES[endpoint.getAttributes() & 3]
+                    endpoint_direction = (
+                        'OUT'
+                        if (endpoint.getAddress() & USB_ENDPOINT_IN == 0)
+                        else 'IN'
+                    )
+                    print(
+                        f'        Endpoint 0x{endpoint.getAddress():02X}: '
+                        f'{endpoint_type} {endpoint_direction}'
+                    )
+
+
+# -----------------------------------------------------------------------------
+def get_class_info(cls, subclass, protocol):
+    class_info = USB_DEVICE_CLASSES.get(cls)
+    protocol_string = ''
+    if class_info is None:
+        class_string = f'0x{cls:02X}'
+    else:
+        if isinstance(class_info, tuple):
+            class_string = class_info[0]
+            subclass_info = class_info[1].get(subclass)
+            if subclass_info:
+                protocol_string = subclass_info.get(protocol)
+                if protocol_string is not None:
+                    protocol_string = f' [{protocol_string}]'
+
+        else:
+            class_string = class_info
+
+    subclass_string = f'{subclass}/{protocol}{protocol_string}'
+
+    return (class_string, subclass_string)
+
+
+# -----------------------------------------------------------------------------
+def is_bluetooth_hci(device):
+    # Check if the device class indicates a match
+    if (
+        device.getDeviceClass(),
+        device.getDeviceSubClass(),
+        device.getDeviceProtocol(),
+    ) == USB_BT_HCI_CLASS_TUPLE:
+        return True
+
+    # If the device class is 'Device', look for a matching interface
+    if device.getDeviceClass() == USB_DEVICE_CLASS_DEVICE:
+        for configuration in device:
+            for interface in configuration:
+                for setting in interface:
+                    if (
+                        setting.getClass(),
+                        setting.getSubClass(),
+                        setting.getProtocol(),
+                    ) == USB_BT_HCI_CLASS_TUPLE:
+                        return True
+
+    return False
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--verbose', is_flag=True, default=False, help='Print more details')
+def main(verbose):
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+
+    load_libusb()
+    with usb1.USBContext() as context:
+        bluetooth_device_count = 0
+        devices = {}
+
+        for device in context.getDeviceIterator(skip_on_error=True):
+            device_class = device.getDeviceClass()
+            device_subclass = device.getDeviceSubClass()
+            device_protocol = device.getDeviceProtocol()
+
+            device_id = (device.getVendorID(), device.getProductID())
+
+            (device_class_string, device_subclass_string) = get_class_info(
+                device_class, device_subclass, device_protocol
+            )
+
+            try:
+                device_serial_number = device.getSerialNumber()
+            except usb1.USBError:
+                device_serial_number = None
+
+            try:
+                device_manufacturer = device.getManufacturer()
+            except usb1.USBError:
+                device_manufacturer = None
+
+            try:
+                device_product = device.getProduct()
+            except usb1.USBError:
+                device_product = None
+
+            device_is_bluetooth_hci = is_bluetooth_hci(device)
+            if device_is_bluetooth_hci:
+                bluetooth_device_count += 1
+                fg_color = 'black'
+                bg_color = 'yellow'
+            else:
+                fg_color = 'yellow'
+                bg_color = 'black'
+
+            # Compute the different ways this can be referenced as a Bumble transport
+            bumble_transport_names = []
+            basic_transport_name = (
+                f'usb:{device.getVendorID():04X}:{device.getProductID():04X}'
+            )
+
+            if device_is_bluetooth_hci:
+                bumble_transport_names.append(f'usb:{bluetooth_device_count - 1}')
+
+            if device_id not in devices:
+                bumble_transport_names.append(basic_transport_name)
+            else:
+                bumble_transport_names.append(
+                    f'{basic_transport_name}#{len(devices[device_id])}'
+                )
+
+            if device_serial_number is not None:
+                if (
+                    device_id not in devices
+                    or device_serial_number not in devices[device_id]
+                ):
+                    bumble_transport_names.append(
+                        f'{basic_transport_name}/{device_serial_number}'
+                    )
+
+            # Print the results
+            print(
+                color(
+                    f'ID {device.getVendorID():04X}:{device.getProductID():04X}',
+                    fg=fg_color,
+                    bg=bg_color,
+                )
+            )
+            if bumble_transport_names:
+                print(
+                    color('  Bumble Transport Names:', 'blue'),
+                    ' or '.join(
+                        color(x, 'cyan' if device_is_bluetooth_hci else 'red')
+                        for x in bumble_transport_names
+                    ),
+                )
+            print(
+                color('  Bus/Device:            ', 'green'),
+                f'{device.getBusNumber():03}/{device.getDeviceAddress():03}',
+            )
+            print(color('  Class:                 ', 'green'), device_class_string)
+            print(color('  Subclass/Protocol:     ', 'green'), device_subclass_string)
+            if device_serial_number is not None:
+                print(color('  Serial:                ', 'green'), device_serial_number)
+            if device_manufacturer is not None:
+                print(color('  Manufacturer:          ', 'green'), device_manufacturer)
+            if device_product is not None:
+                print(color('  Product:               ', 'green'), device_product)
+
+            if verbose:
+                show_device_details(device)
+
+            print()
+
+            devices.setdefault(device_id, []).append(device_serial_number)
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()  # pylint: disable=no-value-for-parameter

assets/_mkdocstrings.css

@@ -1,237 +0,0 @@
-
-/* Avoid breaking parameter names, etc. in table cells. */
-.doc-contents td code {
-  word-break: normal !important;
-}
-
-/* No line break before first paragraph of descriptions. */
-.doc-md-description,
-.doc-md-description>p:first-child {
-  display: inline;
-}
-
-/* No text transformation from Material for MkDocs for H5 headings. */
-.md-typeset h5 .doc-object-name {
-  text-transform: none;
-}
-
-/* Max width for docstring sections tables. */
-.doc .md-typeset__table,
-.doc .md-typeset__table table {
-  display: table !important;
-  width: 100%;
-}
-
-.doc .md-typeset__table tr {
-  display: table-row;
-}
-
-/* Defaults in Spacy table style. */
-.doc-param-default,
-.doc-type_param-default {
-  float: right;
-}
-
-/* Parameter headings must be inline, not blocks. */
-.doc-heading-parameter,
-.doc-heading-type_parameter {
-  display: inline;
-}
-
-/* Default font size for parameter headings. */
-.md-typeset .doc-heading-parameter {
-  font-size: inherit;
-}
-
-/* Prefer space on the right, not the left of parameter permalinks. */
-.doc-heading-parameter .headerlink,
-.doc-heading-type_parameter .headerlink {
-  margin-left: 0 !important;
-  margin-right: 0.2rem;
-}
-
-/* Backward-compatibility: docstring section titles in bold. */
-.doc-section-title {
-  font-weight: bold;
-}
-
-/* Backlinks crumb separator. */
-.doc-backlink-crumb {
-  display: inline-flex;
-  gap: .2rem;
-  white-space: nowrap;
-  align-items: center;
-  vertical-align: middle;
-}
-.doc-backlink-crumb:not(:first-child)::before {
-  background-color: var(--md-default-fg-color--lighter);
-  content: "";
-  display: inline;
-  height: 1rem;
-  --md-path-icon: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M8.59 16.58 13.17 12 8.59 7.41 10 6l6 6-6 6z"/></svg>');
-  -webkit-mask-image: var(--md-path-icon);
-  mask-image: var(--md-path-icon);
-  width: 1rem;
-}
-.doc-backlink-crumb.last {
-  font-weight: bold;
-}
-
-/* Symbols in Navigation and ToC. */
-:root, :host,
-[data-md-color-scheme="default"] {
-  --doc-symbol-parameter-fg-color: #df50af;
-  --doc-symbol-type_parameter-fg-color: #df50af;
-  --doc-symbol-attribute-fg-color: #953800;
-  --doc-symbol-function-fg-color: #8250df;
-  --doc-symbol-method-fg-color: #8250df;
-  --doc-symbol-class-fg-color: #0550ae;
-  --doc-symbol-type_alias-fg-color: #0550ae;
-  --doc-symbol-module-fg-color: #5cad0f;
-
-  --doc-symbol-parameter-bg-color: #df50af1a;
-  --doc-symbol-type_parameter-bg-color: #df50af1a;
-  --doc-symbol-attribute-bg-color: #9538001a;
-  --doc-symbol-function-bg-color: #8250df1a;
-  --doc-symbol-method-bg-color: #8250df1a;
-  --doc-symbol-class-bg-color: #0550ae1a;
-  --doc-symbol-type_alias-bg-color: #0550ae1a;
-  --doc-symbol-module-bg-color: #5cad0f1a;
-}
-
-[data-md-color-scheme="slate"] {
-  --doc-symbol-parameter-fg-color: #ffa8cc;
-  --doc-symbol-type_parameter-fg-color: #ffa8cc;
-  --doc-symbol-attribute-fg-color: #ffa657;
-  --doc-symbol-function-fg-color: #d2a8ff;
-  --doc-symbol-method-fg-color: #d2a8ff;
-  --doc-symbol-class-fg-color: #79c0ff;
-  --doc-symbol-type_alias-fg-color: #79c0ff;
-  --doc-symbol-module-fg-color: #baff79;
-
-  --doc-symbol-parameter-bg-color: #ffa8cc1a;
-  --doc-symbol-type_parameter-bg-color: #ffa8cc1a;
-  --doc-symbol-attribute-bg-color: #ffa6571a;
-  --doc-symbol-function-bg-color: #d2a8ff1a;
-  --doc-symbol-method-bg-color: #d2a8ff1a;
-  --doc-symbol-class-bg-color: #79c0ff1a;
-  --doc-symbol-type_alias-bg-color: #79c0ff1a;
-  --doc-symbol-module-bg-color: #baff791a;
-}
-
-code.doc-symbol {
-  border-radius: .1rem;
-  font-size: .85em;
-  padding: 0 .3em;
-  font-weight: bold;
-}
-
-code.doc-symbol-parameter,
-a code.doc-symbol-parameter {
-  color: var(--doc-symbol-parameter-fg-color);
-  background-color: var(--doc-symbol-parameter-bg-color);
-}
-
-code.doc-symbol-parameter::after {
-  content: "param";
-}
-
-code.doc-symbol-type_parameter,
-a code.doc-symbol-type_parameter {
-  color: var(--doc-symbol-type_parameter-fg-color);
-  background-color: var(--doc-symbol-type_parameter-bg-color);
-}
-
-code.doc-symbol-type_parameter::after {
-  content: "type-param";
-}
-
-code.doc-symbol-attribute,
-a code.doc-symbol-attribute {
-  color: var(--doc-symbol-attribute-fg-color);
-  background-color: var(--doc-symbol-attribute-bg-color);
-}
-
-code.doc-symbol-attribute::after {
-  content: "attr";
-}
-
-code.doc-symbol-function,
-a code.doc-symbol-function {
-  color: var(--doc-symbol-function-fg-color);
-  background-color: var(--doc-symbol-function-bg-color);
-}
-
-code.doc-symbol-function::after {
-  content: "func";
-}
-
-code.doc-symbol-method,
-a code.doc-symbol-method {
-  color: var(--doc-symbol-method-fg-color);
-  background-color: var(--doc-symbol-method-bg-color);
-}
-
-code.doc-symbol-method::after {
-  content: "meth";
-}
-
-code.doc-symbol-class,
-a code.doc-symbol-class {
-  color: var(--doc-symbol-class-fg-color);
-  background-color: var(--doc-symbol-class-bg-color);
-}
-
-code.doc-symbol-class::after {
-  content: "class";
-}
-
-
-code.doc-symbol-type_alias,
-a code.doc-symbol-type_alias {
-  color: var(--doc-symbol-type_alias-fg-color);
-  background-color: var(--doc-symbol-type_alias-bg-color);
-}
-
-code.doc-symbol-type_alias::after {
-  content: "type";
-}
-
-code.doc-symbol-module,
-a code.doc-symbol-module {
-  color: var(--doc-symbol-module-fg-color);
-  background-color: var(--doc-symbol-module-bg-color);
-}
-
-code.doc-symbol-module::after {
-  content: "mod";
-}
-
-.doc-signature .autorefs {
-  color: inherit;
-  border-bottom: 1px dotted currentcolor;
-}
-
-/* Source code blocks (admonitions). */
-:root {
-  --md-admonition-icon--mkdocstrings-source: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M15.22 4.97a.75.75 0 0 1 1.06 0l6.5 6.5a.75.75 0 0 1 0 1.06l-6.5 6.5a.749.749 0 0 1-1.275-.326.75.75 0 0 1 .215-.734L21.19 12l-5.97-5.97a.75.75 0 0 1 0-1.06m-6.44 0a.75.75 0 0 1 0 1.06L2.81 12l5.97 5.97a.749.749 0 0 1-.326 1.275.75.75 0 0 1-.734-.215l-6.5-6.5a.75.75 0 0 1 0-1.06l6.5-6.5a.75.75 0 0 1 1.06 0"/></svg>')
-}
-.md-typeset .admonition.mkdocstrings-source,
-.md-typeset details.mkdocstrings-source {
-  border: none;
-  padding: 0;
-}
-.md-typeset .admonition.mkdocstrings-source:focus-within,
-.md-typeset details.mkdocstrings-source:focus-within {
-  box-shadow: none;
-}
-.md-typeset .mkdocstrings-source > .admonition-title,
-.md-typeset .mkdocstrings-source > summary {
-  background-color: inherit;
-}
-.md-typeset .mkdocstrings-source > .admonition-title::before,
-.md-typeset .mkdocstrings-source > summary::before {
-  background-color: var(--md-default-fg-color);
-  -webkit-mask-image: var(--md-admonition-icon--mkdocstrings-source);
-          mask-image: var(--md-admonition-icon--mkdocstrings-source);
-}

assets/javascripts/lunr/min/lunr.da.min.js

@@ -1,18 +0,0 @@
-/*!
- * Lunr languages, `Danish` language
- * https://github.com/MihaiValentin/lunr-languages
- *
- * Copyright 2014, Mihai Valentin
- * http://www.mozilla.org/MPL/
- */
-/*!
- * based on
- * Snowball JavaScript Library v0.3
- * http://code.google.com/p/urim/
- * http://snowball.tartarus.org/
- *
- * Copyright 2010, Oleg Mazko
- * http://www.mozilla.org/MPL/
- */
-
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.da=function(){this.pipeline.reset(),this.pipeline.add(e.da.trimmer,e.da.stopWordFilter,e.da.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.da.stemmer))},e.da.wordCharacters="A-Za-zªºÀ-ÖØ-öø-ʸˠ-ˤᴀ-ᴥᴬ-ᵜᵢ-ᵥᵫ-ᵷᵹ-ᶾḀ-ỿⁱⁿₐ-ₜKÅℲⅎⅠ-ↈⱠ-ⱿꜢ-ꞇꞋ-ꞭꞰ-ꞷꟷ-ꟿꬰ-ꭚꭜ-ꭤff-stＡ-Ｚａ-ｚ",e.da.trimmer=e.trimmerSupport.generateTrimmer(e.da.wordCharacters),e.Pipeline.registerFunction(e.da.trimmer,"trimmer-da"),e.da.stemmer=function(){var r=e.stemmerSupport.Among,i=e.stemmerSupport.SnowballProgram,n=new function(){function e(){var e,r=f.cursor+3;if(d=f.limit,0<=r&&r<=f.limit){for(a=r;;){if(e=f.cursor,f.in_grouping(w,97,248)){f.cursor=e;break}if(f.cursor=e,e>=f.limit)return;f.cursor++}for(;!f.out_grouping(w,97,248);){if(f.cursor>=f.limit)return;f.cursor++}d=f.cursor,d<a&&(d=a)}}function n(){var e,r;if(f.cursor>=d&&(r=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,e=f.find_among_b(c,32),f.limit_backward=r,e))switch(f.bra=f.cursor,e){case 1:f.slice_del();break;case 2:f.in_grouping_b(p,97,229)&&f.slice_del()}}function t(){var e,r=f.limit-f.cursor;f.cursor>=d&&(e=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,f.find_among_b(l,4)?(f.bra=f.cursor,f.limit_backward=e,f.cursor=f.limit-r,f.cursor>f.limit_backward&&(f.cursor--,f.bra=f.cursor,f.slice_del())):f.limit_backward=e)}function s(){var e,r,i,n=f.limit-f.cursor;if(f.ket=f.cursor,f.eq_s_b(2,"st")&&(f.bra=f.cursor,f.eq_s_b(2,"ig")&&f.slice_del()),f.cursor=f.limit-n,f.cursor>=d&&(r=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,e=f.find_among_b(m,5),f.limit_backward=r,e))switch(f.bra=f.cursor,e){case 1:f.slice_del(),i=f.limit-f.cursor,t(),f.cursor=f.limit-i;break;case 2:f.slice_from("løs")}}function o(){var e;f.cursor>=d&&(e=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,f.out_grouping_b(w,97,248)?(f.bra=f.cursor,u=f.slice_to(u),f.limit_backward=e,f.eq_v_b(u)&&f.slice_del()):f.limit_backward=e)}var a,d,u,c=[new r("hed",-1,1),new r("ethed",0,1),new r("ered",-1,1),new r("e",-1,1),new r("erede",3,1),new r("ende",3,1),new r("erende",5,1),new r("ene",3,1),new r("erne",3,1),new r("ere",3,1),new r("en",-1,1),new r("heden",10,1),new r("eren",10,1),new r("er",-1,1),new r("heder",13,1),new r("erer",13,1),new r("s",-1,2),new r("heds",16,1),new r("es",16,1),new r("endes",18,1),new r("erendes",19,1),new r("enes",18,1),new r("ernes",18,1),new r("eres",18,1),new r("ens",16,1),new r("hedens",24,1),new r("erens",24,1),new r("ers",16,1),new r("ets",16,1),new r("erets",28,1),new r("et",-1,1),new r("eret",30,1)],l=[new r("gd",-1,-1),new r("dt",-1,-1),new r("gt",-1,-1),new r("kt",-1,-1)],m=[new r("ig",-1,1),new r("lig",0,1),new r("elig",1,1),new r("els",-1,1),new r("løst",-1,2)],w=[17,65,16,1,0,0,0,0,0,0,0,0,0,0,0,0,48,0,128],p=[239,254,42,3,0,0,0,0,0,0,0,0,0,0,0,0,16],f=new i;this.setCurrent=function(e){f.setCurrent(e)},this.getCurrent=function(){return f.getCurrent()},this.stem=function(){var r=f.cursor;return e(),f.limit_backward=r,f.cursor=f.limit,n(),f.cursor=f.limit,t(),f.cursor=f.limit,s(),f.cursor=f.limit,o(),!0}};return function(e){return"function"==typeof e.update?e.update(function(e){return n.setCurrent(e),n.stem(),n.getCurrent()}):(n.setCurrent(e),n.stem(),n.getCurrent())}}(),e.Pipeline.registerFunction(e.da.stemmer,"stemmer-da"),e.da.stopWordFilter=e.generateStopWordFilter("ad af alle alt anden at blev blive bliver da de dem den denne der deres det dette dig din disse dog du efter eller en end er et for fra ham han hans har havde have hende hendes her hos hun hvad hvis hvor i ikke ind jeg jer jo kunne man mange med meget men mig min mine mit mod ned noget nogle nu når og også om op os over på selv sig sin sine sit skal skulle som sådan thi til ud under var vi vil ville vor være været".split(" ")),e.Pipeline.registerFunction(e.da.stopWordFilter,"stopWordFilter-da")}});

assets/javascripts/lunr/min/lunr.hi.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.hi=function(){this.pipeline.reset(),this.pipeline.add(e.hi.trimmer,e.hi.stopWordFilter,e.hi.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.hi.stemmer))},e.hi.wordCharacters="ऀ-ःऄ-एऐ-टठ-यर-िी-ॏॐ-य़ॠ-९॰-ॿa-zA-Zａ-ｚＡ-Ｚ0-9０-９",e.hi.trimmer=e.trimmerSupport.generateTrimmer(e.hi.wordCharacters),e.Pipeline.registerFunction(e.hi.trimmer,"trimmer-hi"),e.hi.stopWordFilter=e.generateStopWordFilter("अत अपना अपनी अपने अभी अंदर आदि आप इत्यादि इन इनका इन्हीं इन्हें इन्हों इस इसका इसकी इसके इसमें इसी इसे उन उनका उनकी उनके उनको उन्हीं उन्हें उन्हों उस उसके उसी उसे एक एवं एस ऐसे और कई कर करता करते करना करने करें कहते कहा का काफ़ी कि कितना किन्हें किन्हों किया किर किस किसी किसे की कुछ कुल के को कोई कौन कौनसा गया घर जब जहाँ जा जितना जिन जिन्हें जिन्हों जिस जिसे जीधर जैसा जैसे जो तक तब तरह तिन तिन्हें तिन्हों तिस तिसे तो था थी थे दबारा दिया दुसरा दूसरे दो द्वारा न नके नहीं ना निहायत नीचे ने पर पहले पूरा पे फिर बनी बही बहुत बाद बाला बिलकुल भी भीतर मगर मानो मे में यदि यह यहाँ यही या यिह ये रखें रहा रहे ऱ्वासा लिए लिये लेकिन व वग़ैरह वर्ग वह वहाँ वहीं वाले वुह वे वो सकता सकते सबसे सभी साथ साबुत साभ सारा से सो संग ही हुआ हुई हुए है हैं हो होता होती होते होना होने".split(" ")),e.hi.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var r=e.wordcut;r.init(),e.hi.tokenizer=function(i){if(!arguments.length||null==i||void 0==i)return[];if(Array.isArray(i))return i.map(function(r){return isLunr2?new e.Token(r.toLowerCase()):r.toLowerCase()});var t=i.toString().toLowerCase().replace(/^\s+/,"");return r.cut(t).split("|")},e.Pipeline.registerFunction(e.hi.stemmer,"stemmer-hi"),e.Pipeline.registerFunction(e.hi.stopWordFilter,"stopWordFilter-hi")}});

assets/javascripts/lunr/min/lunr.hy.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.hy=function(){this.pipeline.reset(),this.pipeline.add(e.hy.trimmer,e.hy.stopWordFilter)},e.hy.wordCharacters="[A-Za-z԰-֏ff-ﭏ]",e.hy.trimmer=e.trimmerSupport.generateTrimmer(e.hy.wordCharacters),e.Pipeline.registerFunction(e.hy.trimmer,"trimmer-hy"),e.hy.stopWordFilter=e.generateStopWordFilter("դու և եք էիր էիք հետո նաև նրանք որը վրա է որ պիտի են այս մեջ ն իր ու ի այդ որոնք այն կամ էր մի ես համար այլ իսկ էին ենք հետ ին թ էինք մենք նրա նա դուք եմ էի ըստ որպես ում".split(" ")),e.Pipeline.registerFunction(e.hy.stopWordFilter,"stopWordFilter-hy"),e.hy.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}(),e.Pipeline.registerFunction(e.hy.stemmer,"stemmer-hy")}});

assets/javascripts/lunr/min/lunr.ja.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");var r="2"==e.version[0];e.ja=function(){this.pipeline.reset(),this.pipeline.add(e.ja.trimmer,e.ja.stopWordFilter,e.ja.stemmer),r?this.tokenizer=e.ja.tokenizer:(e.tokenizer&&(e.tokenizer=e.ja.tokenizer),this.tokenizerFn&&(this.tokenizerFn=e.ja.tokenizer))};var t=new e.TinySegmenter;e.ja.tokenizer=function(i){var n,o,s,p,a,u,m,l,c,f;if(!arguments.length||null==i||void 0==i)return[];if(Array.isArray(i))return i.map(function(t){return r?new e.Token(t.toLowerCase()):t.toLowerCase()});for(o=i.toString().toLowerCase().replace(/^\s+/,""),n=o.length-1;n>=0;n--)if(/\S/.test(o.charAt(n))){o=o.substring(0,n+1);break}for(a=[],s=o.length,c=0,l=0;c<=s;c++)if(u=o.charAt(c),m=c-l,u.match(/\s/)||c==s){if(m>0)for(p=t.segment(o.slice(l,c)).filter(function(e){return!!e}),f=l,n=0;n<p.length;n++)r?a.push(new e.Token(p[n],{position:[f,p[n].length],index:a.length})):a.push(p[n]),f+=p[n].length;l=c+1}return a},e.ja.stemmer=function(){return function(e){return e}}(),e.Pipeline.registerFunction(e.ja.stemmer,"stemmer-ja"),e.ja.wordCharacters="一二三四五六七八九十百千万億兆一-龠々〆ヵヶぁ-んァ-ヴーｱ-ﾝﾞa-zA-Zａ-ｚＡ-Ｚ0-9０-９",e.ja.trimmer=e.trimmerSupport.generateTrimmer(e.ja.wordCharacters),e.Pipeline.registerFunction(e.ja.trimmer,"trimmer-ja"),e.ja.stopWordFilter=e.generateStopWordFilter("これ それ あれ この その あの ここ そこ あそこ こちら どこ だれ なに なん 何 私 貴方 貴方方 我々 私達 あの人 あのかた 彼女 彼 です あります おります います は が の に を で え から まで より も どの と し それで しかし".split(" ")),e.Pipeline.registerFunction(e.ja.stopWordFilter,"stopWordFilter-ja"),e.jp=e.ja,e.Pipeline.registerFunction(e.jp.stemmer,"stemmer-jp"),e.Pipeline.registerFunction(e.jp.trimmer,"trimmer-jp"),e.Pipeline.registerFunction(e.jp.stopWordFilter,"stopWordFilter-jp")}});

assets/javascripts/lunr/min/lunr.jp.min.js

@@ -1 +0,0 @@
-module.exports=require("./lunr.ja");

assets/javascripts/lunr/min/lunr.kn.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.kn=function(){this.pipeline.reset(),this.pipeline.add(e.kn.trimmer,e.kn.stopWordFilter,e.kn.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.kn.stemmer))},e.kn.wordCharacters="ಀ-಄ಅ-ಔಕ-ಹಾ-ೌ಼-ಽೕ-ೖೝ-ೞೠ-ೡೢ-ೣ೤೥೦-೯ೱ-ೳ",e.kn.trimmer=e.trimmerSupport.generateTrimmer(e.kn.wordCharacters),e.Pipeline.registerFunction(e.kn.trimmer,"trimmer-kn"),e.kn.stopWordFilter=e.generateStopWordFilter("ಮತ್ತು ಈ ಒಂದು ರಲ್ಲಿ ಹಾಗೂ ಎಂದು ಅಥವಾ ಇದು ರ ಅವರು ಎಂಬ ಮೇಲೆ ಅವರ ತನ್ನ ಆದರೆ ತಮ್ಮ ನಂತರ ಮೂಲಕ ಹೆಚ್ಚು ನ ಆ ಕೆಲವು ಅನೇಕ ಎರಡು ಹಾಗು ಪ್ರಮುಖ ಇದನ್ನು ಇದರ ಸುಮಾರು ಅದರ ಅದು ಮೊದಲ ಬಗ್ಗೆ ನಲ್ಲಿ ರಂದು ಇತರ ಅತ್ಯಂತ ಹೆಚ್ಚಿನ ಸಹ ಸಾಮಾನ್ಯವಾಗಿ ನೇ ಹಲವಾರು ಹೊಸ ದಿ ಕಡಿಮೆ ಯಾವುದೇ ಹೊಂದಿದೆ ದೊಡ್ಡ ಅನ್ನು ಇವರು ಪ್ರಕಾರ ಇದೆ ಮಾತ್ರ ಕೂಡ ಇಲ್ಲಿ ಎಲ್ಲಾ ವಿವಿಧ ಅದನ್ನು ಹಲವು ರಿಂದ ಕೇವಲ ದ ದಕ್ಷಿಣ ಗೆ ಅವನ ಅತಿ ನೆಯ ಬಹಳ ಕೆಲಸ ಎಲ್ಲ ಪ್ರತಿ ಇತ್ಯಾದಿ ಇವು ಬೇರೆ ಹೀಗೆ ನಡುವೆ ಇದಕ್ಕೆ ಎಸ್ ಇವರ ಮೊದಲು ಶ್ರೀ ಮಾಡುವ ಇದರಲ್ಲಿ ರೀತಿಯ ಮಾಡಿದ ಕಾಲ ಅಲ್ಲಿ ಮಾಡಲು ಅದೇ ಈಗ ಅವು ಗಳು ಎ ಎಂಬುದು ಅವನು ಅಂದರೆ ಅವರಿಗೆ ಇರುವ ವಿಶೇಷ ಮುಂದೆ ಅವುಗಳ ಮುಂತಾದ ಮೂಲ ಬಿ ಮೀ ಒಂದೇ ಇನ್ನೂ ಹೆಚ್ಚಾಗಿ ಮಾಡಿ ಅವರನ್ನು ಇದೇ ಯ ರೀತಿಯಲ್ಲಿ ಜೊತೆ ಅದರಲ್ಲಿ ಮಾಡಿದರು ನಡೆದ ಆಗ ಮತ್ತೆ ಪೂರ್ವ ಆತ ಬಂದ ಯಾವ ಒಟ್ಟು ಇತರೆ ಹಿಂದೆ ಪ್ರಮಾಣದ ಗಳನ್ನು ಕುರಿತು ಯು ಆದ್ದರಿಂದ ಅಲ್ಲದೆ ನಗರದ ಮೇಲಿನ ಏಕೆಂದರೆ ರಷ್ಟು ಎಂಬುದನ್ನು ಬಾರಿ ಎಂದರೆ ಹಿಂದಿನ ಆದರೂ ಆದ ಸಂಬಂಧಿಸಿದ ಮತ್ತೊಂದು ಸಿ ಆತನ ".split(" ")),e.kn.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var r=e.wordcut;r.init(),e.kn.tokenizer=function(t){if(!arguments.length||null==t||void 0==t)return[];if(Array.isArray(t))return t.map(function(r){return isLunr2?new e.Token(r.toLowerCase()):r.toLowerCase()});var n=t.toString().toLowerCase().replace(/^\s+/,"");return r.cut(n).split("|")},e.Pipeline.registerFunction(e.kn.stemmer,"stemmer-kn"),e.Pipeline.registerFunction(e.kn.stopWordFilter,"stopWordFilter-kn")}});

assets/javascripts/lunr/min/lunr.multi.min.js

@@ -1 +0,0 @@
-!function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){e.multiLanguage=function(){for(var t=Array.prototype.slice.call(arguments),i=t.join("-"),r="",n=[],s=[],p=0;p<t.length;++p)"en"==t[p]?(r+="\\w",n.unshift(e.stopWordFilter),n.push(e.stemmer),s.push(e.stemmer)):(r+=e[t[p]].wordCharacters,e[t[p]].stopWordFilter&&n.unshift(e[t[p]].stopWordFilter),e[t[p]].stemmer&&(n.push(e[t[p]].stemmer),s.push(e[t[p]].stemmer)));var o=e.trimmerSupport.generateTrimmer(r);return e.Pipeline.registerFunction(o,"lunr-multi-trimmer-"+i),n.unshift(o),function(){this.pipeline.reset(),this.pipeline.add.apply(this.pipeline,n),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add.apply(this.searchPipeline,s))}}}});

assets/javascripts/lunr/min/lunr.no.min.js

@@ -1,18 +0,0 @@
-/*!
- * Lunr languages, `Norwegian` language
- * https://github.com/MihaiValentin/lunr-languages
- *
- * Copyright 2014, Mihai Valentin
- * http://www.mozilla.org/MPL/
- */
-/*!
- * based on
- * Snowball JavaScript Library v0.3
- * http://code.google.com/p/urim/
- * http://snowball.tartarus.org/
- *
- * Copyright 2010, Oleg Mazko
- * http://www.mozilla.org/MPL/
- */
-
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.no=function(){this.pipeline.reset(),this.pipeline.add(e.no.trimmer,e.no.stopWordFilter,e.no.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.no.stemmer))},e.no.wordCharacters="A-Za-zªºÀ-ÖØ-öø-ʸˠ-ˤᴀ-ᴥᴬ-ᵜᵢ-ᵥᵫ-ᵷᵹ-ᶾḀ-ỿⁱⁿₐ-ₜKÅℲⅎⅠ-ↈⱠ-ⱿꜢ-ꞇꞋ-ꞭꞰ-ꞷꟷ-ꟿꬰ-ꭚꭜ-ꭤff-stＡ-Ｚａ-ｚ",e.no.trimmer=e.trimmerSupport.generateTrimmer(e.no.wordCharacters),e.Pipeline.registerFunction(e.no.trimmer,"trimmer-no"),e.no.stemmer=function(){var r=e.stemmerSupport.Among,n=e.stemmerSupport.SnowballProgram,i=new function(){function e(){var e,r=w.cursor+3;if(a=w.limit,0<=r||r<=w.limit){for(s=r;;){if(e=w.cursor,w.in_grouping(d,97,248)){w.cursor=e;break}if(e>=w.limit)return;w.cursor=e+1}for(;!w.out_grouping(d,97,248);){if(w.cursor>=w.limit)return;w.cursor++}a=w.cursor,a<s&&(a=s)}}function i(){var e,r,n;if(w.cursor>=a&&(r=w.limit_backward,w.limit_backward=a,w.ket=w.cursor,e=w.find_among_b(m,29),w.limit_backward=r,e))switch(w.bra=w.cursor,e){case 1:w.slice_del();break;case 2:n=w.limit-w.cursor,w.in_grouping_b(c,98,122)?w.slice_del():(w.cursor=w.limit-n,w.eq_s_b(1,"k")&&w.out_grouping_b(d,97,248)&&w.slice_del());break;case 3:w.slice_from("er")}}function t(){var e,r=w.limit-w.cursor;w.cursor>=a&&(e=w.limit_backward,w.limit_backward=a,w.ket=w.cursor,w.find_among_b(u,2)?(w.bra=w.cursor,w.limit_backward=e,w.cursor=w.limit-r,w.cursor>w.limit_backward&&(w.cursor--,w.bra=w.cursor,w.slice_del())):w.limit_backward=e)}function o(){var e,r;w.cursor>=a&&(r=w.limit_backward,w.limit_backward=a,w.ket=w.cursor,e=w.find_among_b(l,11),e?(w.bra=w.cursor,w.limit_backward=r,1==e&&w.slice_del()):w.limit_backward=r)}var s,a,m=[new r("a",-1,1),new r("e",-1,1),new r("ede",1,1),new r("ande",1,1),new r("ende",1,1),new r("ane",1,1),new r("ene",1,1),new r("hetene",6,1),new r("erte",1,3),new r("en",-1,1),new r("heten",9,1),new r("ar",-1,1),new r("er",-1,1),new r("heter",12,1),new r("s",-1,2),new r("as",14,1),new r("es",14,1),new r("edes",16,1),new r("endes",16,1),new r("enes",16,1),new r("hetenes",19,1),new r("ens",14,1),new r("hetens",21,1),new r("ers",14,1),new r("ets",14,1),new r("et",-1,1),new r("het",25,1),new r("ert",-1,3),new r("ast",-1,1)],u=[new r("dt",-1,-1),new r("vt",-1,-1)],l=[new r("leg",-1,1),new r("eleg",0,1),new r("ig",-1,1),new r("eig",2,1),new r("lig",2,1),new r("elig",4,1),new r("els",-1,1),new r("lov",-1,1),new r("elov",7,1),new r("slov",7,1),new r("hetslov",9,1)],d=[17,65,16,1,0,0,0,0,0,0,0,0,0,0,0,0,48,0,128],c=[119,125,149,1],w=new n;this.setCurrent=function(e){w.setCurrent(e)},this.getCurrent=function(){return w.getCurrent()},this.stem=function(){var r=w.cursor;return e(),w.limit_backward=r,w.cursor=w.limit,i(),w.cursor=w.limit,t(),w.cursor=w.limit,o(),!0}};return function(e){return"function"==typeof e.update?e.update(function(e){return i.setCurrent(e),i.stem(),i.getCurrent()}):(i.setCurrent(e),i.stem(),i.getCurrent())}}(),e.Pipeline.registerFunction(e.no.stemmer,"stemmer-no"),e.no.stopWordFilter=e.generateStopWordFilter("alle at av bare begge ble blei bli blir blitt både båe da de deg dei deim deira deires dem den denne der dere deres det dette di din disse ditt du dykk dykkar då eg ein eit eitt eller elles en enn er et ett etter for fordi fra før ha hadde han hans har hennar henne hennes her hjå ho hoe honom hoss hossen hun hva hvem hver hvilke hvilken hvis hvor hvordan hvorfor i ikke ikkje ikkje ingen ingi inkje inn inni ja jeg kan kom korleis korso kun kunne kva kvar kvarhelst kven kvi kvifor man mange me med medan meg meget mellom men mi min mine mitt mot mykje ned no noe noen noka noko nokon nokor nokre nå når og også om opp oss over på samme seg selv si si sia sidan siden sin sine sitt sjøl skal skulle slik so som som somme somt så sånn til um upp ut uten var vart varte ved vere verte vi vil ville vore vors vort vår være være vært å".split(" ")),e.Pipeline.registerFunction(e.no.stopWordFilter,"stopWordFilter-no")}});

assets/javascripts/lunr/min/lunr.sa.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.sa=function(){this.pipeline.reset(),this.pipeline.add(e.sa.trimmer,e.sa.stopWordFilter,e.sa.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.sa.stemmer))},e.sa.wordCharacters="ऀ-ःऄ-एऐ-टठ-यर-िी-ॏॐ-य़ॠ-९॰-ॿ꣠-꣱ꣲ-ꣷ꣸-ꣻ꣼-ꣽꣾ-ꣿᆰ0-ᆰ9",e.sa.trimmer=e.trimmerSupport.generateTrimmer(e.sa.wordCharacters),e.Pipeline.registerFunction(e.sa.trimmer,"trimmer-sa"),e.sa.stopWordFilter=e.generateStopWordFilter('तथा अयम्‌ एकम्‌ इत्यस्मिन्‌ तथा तत्‌ वा अयम्‌ इत्यस्य ते आहूत उपरि तेषाम्‌  किन्तु तेषाम्‌ तदा इत्यनेन अधिकः इत्यस्य तत्‌ केचन बहवः द्वि तथा महत्वपूर्णः अयम्‌ अस्य  विषये अयं अस्ति तत्‌ प्रथमः विषये इत्युपरि इत्युपरि इतर अधिकतमः अधिकः अपि सामान्यतया ठ इतरेतर नूतनम्‌ द  न्यूनम्‌ कश्चित्‌ वा विशालः द  सः अस्ति तदनुसारम् तत्र अस्ति केवलम्‌ अपि अत्र सर्वे विविधाः तत्‌ बहवः यतः इदानीम्‌ द  दक्षिण इत्यस्मै तस्य उपरि नथ अतीव कार्यम्‌ सर्वे एकैकम्‌ इत्यादि। एते सन्ति  उत इत्थम्‌ मध्ये एतदर्थं . स कस्य प्रथमः श्री. करोति अस्मिन् प्रकारः निर्मिता कालः तत्र कर्तुं  समान अधुना ते सन्ति स एकः अस्ति सः अर्थात् तेषां कृते . स्थितम्  विशेषः अग्रिम तेषाम्‌ समान स्रोतः ख म समान इदानीमपि अधिकतया करोतु ते समान इत्यस्य वीथी सह यस्मिन्  कृतवान्‌ धृतः तदा पुनः पूर्वं सः आगतः किम्‌ कुल इतर पुरा  मात्रा स विषये उ अतएव अपि नगरस्य  उपरि यतः प्रतिशतं  कतरः कालः साधनानि भूत तथापि जात सम्बन्धि अन्यत्‌ ग अतः अस्माकं स्वकीयाः अस्माकं इदानीं अन्तः इत्यादयः भवन्तः इत्यादयः एते एताः तस्य अस्य इदम् एते तेषां तेषां तेषां तान् तेषां तेषां तेषां समानः सः एकः च तादृशाः बहवः अन्ये च वदन्ति यत् कियत् कस्मै  कस्मै  यस्मै  यस्मै  यस्मै  यस्मै न अतिनीचः किन्तु प्रथमं सम्पूर्णतया  ततः चिरकालानन्तरं पुस्तकं सम्पूर्णतया अन्तः  किन्तु अत्र वा इह इव श्रद्धाय अवशिष्यते  परन्तु अन्ये वर्गाः सन्ति ते सन्ति शक्नुवन्ति सर्वे मिलित्वा सर्वे एकत्र"'.split(" ")),e.sa.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var r=e.wordcut;r.init(),e.sa.tokenizer=function(t){if(!arguments.length||null==t||void 0==t)return[];if(Array.isArray(t))return t.map(function(r){return isLunr2?new e.Token(r.toLowerCase()):r.toLowerCase()});var i=t.toString().toLowerCase().replace(/^\s+/,"");return r.cut(i).split("|")},e.Pipeline.registerFunction(e.sa.stemmer,"stemmer-sa"),e.Pipeline.registerFunction(e.sa.stopWordFilter,"stopWordFilter-sa")}});

assets/javascripts/lunr/min/lunr.stemmer.support.min.js

@@ -1 +0,0 @@
-!function(r,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(r.lunr)}(this,function(){return function(r){r.stemmerSupport={Among:function(r,t,i,s){if(this.toCharArray=function(r){for(var t=r.length,i=new Array(t),s=0;s<t;s++)i[s]=r.charCodeAt(s);return i},!r&&""!=r||!t&&0!=t||!i)throw"Bad Among initialisation: s:"+r+", substring_i: "+t+", result: "+i;this.s_size=r.length,this.s=this.toCharArray(r),this.substring_i=t,this.result=i,this.method=s},SnowballProgram:function(){var r;return{bra:0,ket:0,limit:0,cursor:0,limit_backward:0,setCurrent:function(t){r=t,this.cursor=0,this.limit=t.length,this.limit_backward=0,this.bra=this.cursor,this.ket=this.limit},getCurrent:function(){var t=r;return r=null,t},in_grouping:function(t,i,s){if(this.cursor<this.limit){var e=r.charCodeAt(this.cursor);if(e<=s&&e>=i&&(e-=i,t[e>>3]&1<<(7&e)))return this.cursor++,!0}return!1},in_grouping_b:function(t,i,s){if(this.cursor>this.limit_backward){var e=r.charCodeAt(this.cursor-1);if(e<=s&&e>=i&&(e-=i,t[e>>3]&1<<(7&e)))return this.cursor--,!0}return!1},out_grouping:function(t,i,s){if(this.cursor<this.limit){var e=r.charCodeAt(this.cursor);if(e>s||e<i)return this.cursor++,!0;if(e-=i,!(t[e>>3]&1<<(7&e)))return this.cursor++,!0}return!1},out_grouping_b:function(t,i,s){if(this.cursor>this.limit_backward){var e=r.charCodeAt(this.cursor-1);if(e>s||e<i)return this.cursor--,!0;if(e-=i,!(t[e>>3]&1<<(7&e)))return this.cursor--,!0}return!1},eq_s:function(t,i){if(this.limit-this.cursor<t)return!1;for(var s=0;s<t;s++)if(r.charCodeAt(this.cursor+s)!=i.charCodeAt(s))return!1;return this.cursor+=t,!0},eq_s_b:function(t,i){if(this.cursor-this.limit_backward<t)return!1;for(var s=0;s<t;s++)if(r.charCodeAt(this.cursor-t+s)!=i.charCodeAt(s))return!1;return this.cursor-=t,!0},find_among:function(t,i){for(var s=0,e=i,n=this.cursor,u=this.limit,o=0,h=0,c=!1;;){for(var a=s+(e-s>>1),f=0,l=o<h?o:h,_=t[a],m=l;m<_.s_size;m++){if(n+l==u){f=-1;break}if(f=r.charCodeAt(n+l)-_.s[m])break;l++}if(f<0?(e=a,h=l):(s=a,o=l),e-s<=1){if(s>0||e==s||c)break;c=!0}}for(;;){var _=t[s];if(o>=_.s_size){if(this.cursor=n+_.s_size,!_.method)return _.result;var b=_.method();if(this.cursor=n+_.s_size,b)return _.result}if((s=_.substring_i)<0)return 0}},find_among_b:function(t,i){for(var s=0,e=i,n=this.cursor,u=this.limit_backward,o=0,h=0,c=!1;;){for(var a=s+(e-s>>1),f=0,l=o<h?o:h,_=t[a],m=_.s_size-1-l;m>=0;m--){if(n-l==u){f=-1;break}if(f=r.charCodeAt(n-1-l)-_.s[m])break;l++}if(f<0?(e=a,h=l):(s=a,o=l),e-s<=1){if(s>0||e==s||c)break;c=!0}}for(;;){var _=t[s];if(o>=_.s_size){if(this.cursor=n-_.s_size,!_.method)return _.result;var b=_.method();if(this.cursor=n-_.s_size,b)return _.result}if((s=_.substring_i)<0)return 0}},replace_s:function(t,i,s){var e=s.length-(i-t),n=r.substring(0,t),u=r.substring(i);return r=n+s+u,this.limit+=e,this.cursor>=i?this.cursor+=e:this.cursor>t&&(this.cursor=t),e},slice_check:function(){if(this.bra<0||this.bra>this.ket||this.ket>this.limit||this.limit>r.length)throw"faulty slice operation"},slice_from:function(r){this.slice_check(),this.replace_s(this.bra,this.ket,r)},slice_del:function(){this.slice_from("")},insert:function(r,t,i){var s=this.replace_s(r,t,i);r<=this.bra&&(this.bra+=s),r<=this.ket&&(this.ket+=s)},slice_to:function(){return this.slice_check(),r.substring(this.bra,this.ket)},eq_v_b:function(r){return this.eq_s_b(r.length,r)}}}},r.trimmerSupport={generateTrimmer:function(r){var t=new RegExp("^[^"+r+"]+"),i=new RegExp("[^"+r+"]+$");return function(r){return"function"==typeof r.update?r.update(function(r){return r.replace(t,"").replace(i,"")}):r.replace(t,"").replace(i,"")}}}}});

assets/javascripts/lunr/min/lunr.sv.min.js

@@ -1,18 +0,0 @@
-/*!
- * Lunr languages, `Swedish` language
- * https://github.com/MihaiValentin/lunr-languages
- *
- * Copyright 2014, Mihai Valentin
- * http://www.mozilla.org/MPL/
- */
-/*!
- * based on
- * Snowball JavaScript Library v0.3
- * http://code.google.com/p/urim/
- * http://snowball.tartarus.org/
- *
- * Copyright 2010, Oleg Mazko
- * http://www.mozilla.org/MPL/
- */
-
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.sv=function(){this.pipeline.reset(),this.pipeline.add(e.sv.trimmer,e.sv.stopWordFilter,e.sv.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.sv.stemmer))},e.sv.wordCharacters="A-Za-zªºÀ-ÖØ-öø-ʸˠ-ˤᴀ-ᴥᴬ-ᵜᵢ-ᵥᵫ-ᵷᵹ-ᶾḀ-ỿⁱⁿₐ-ₜKÅℲⅎⅠ-ↈⱠ-ⱿꜢ-ꞇꞋ-ꞭꞰ-ꞷꟷ-ꟿꬰ-ꭚꭜ-ꭤff-stＡ-Ｚａ-ｚ",e.sv.trimmer=e.trimmerSupport.generateTrimmer(e.sv.wordCharacters),e.Pipeline.registerFunction(e.sv.trimmer,"trimmer-sv"),e.sv.stemmer=function(){var r=e.stemmerSupport.Among,n=e.stemmerSupport.SnowballProgram,t=new function(){function e(){var e,r=w.cursor+3;if(o=w.limit,0<=r||r<=w.limit){for(a=r;;){if(e=w.cursor,w.in_grouping(l,97,246)){w.cursor=e;break}if(w.cursor=e,w.cursor>=w.limit)return;w.cursor++}for(;!w.out_grouping(l,97,246);){if(w.cursor>=w.limit)return;w.cursor++}o=w.cursor,o<a&&(o=a)}}function t(){var e,r=w.limit_backward;if(w.cursor>=o&&(w.limit_backward=o,w.cursor=w.limit,w.ket=w.cursor,e=w.find_among_b(u,37),w.limit_backward=r,e))switch(w.bra=w.cursor,e){case 1:w.slice_del();break;case 2:w.in_grouping_b(d,98,121)&&w.slice_del()}}function i(){var e=w.limit_backward;w.cursor>=o&&(w.limit_backward=o,w.cursor=w.limit,w.find_among_b(c,7)&&(w.cursor=w.limit,w.ket=w.cursor,w.cursor>w.limit_backward&&(w.bra=--w.cursor,w.slice_del())),w.limit_backward=e)}function s(){var e,r;if(w.cursor>=o){if(r=w.limit_backward,w.limit_backward=o,w.cursor=w.limit,w.ket=w.cursor,e=w.find_among_b(m,5))switch(w.bra=w.cursor,e){case 1:w.slice_del();break;case 2:w.slice_from("lös");break;case 3:w.slice_from("full")}w.limit_backward=r}}var a,o,u=[new r("a",-1,1),new r("arna",0,1),new r("erna",0,1),new r("heterna",2,1),new r("orna",0,1),new r("ad",-1,1),new r("e",-1,1),new r("ade",6,1),new r("ande",6,1),new r("arne",6,1),new r("are",6,1),new r("aste",6,1),new r("en",-1,1),new r("anden",12,1),new r("aren",12,1),new r("heten",12,1),new r("ern",-1,1),new r("ar",-1,1),new r("er",-1,1),new r("heter",18,1),new r("or",-1,1),new r("s",-1,2),new r("as",21,1),new r("arnas",22,1),new r("ernas",22,1),new r("ornas",22,1),new r("es",21,1),new r("ades",26,1),new r("andes",26,1),new r("ens",21,1),new r("arens",29,1),new r("hetens",29,1),new r("erns",21,1),new r("at",-1,1),new r("andet",-1,1),new r("het",-1,1),new r("ast",-1,1)],c=[new r("dd",-1,-1),new r("gd",-1,-1),new r("nn",-1,-1),new r("dt",-1,-1),new r("gt",-1,-1),new r("kt",-1,-1),new r("tt",-1,-1)],m=[new r("ig",-1,1),new r("lig",0,1),new r("els",-1,1),new r("fullt",-1,3),new r("löst",-1,2)],l=[17,65,16,1,0,0,0,0,0,0,0,0,0,0,0,0,24,0,32],d=[119,127,149],w=new n;this.setCurrent=function(e){w.setCurrent(e)},this.getCurrent=function(){return w.getCurrent()},this.stem=function(){var r=w.cursor;return e(),w.limit_backward=r,w.cursor=w.limit,t(),w.cursor=w.limit,i(),w.cursor=w.limit,s(),!0}};return function(e){return"function"==typeof e.update?e.update(function(e){return t.setCurrent(e),t.stem(),t.getCurrent()}):(t.setCurrent(e),t.stem(),t.getCurrent())}}(),e.Pipeline.registerFunction(e.sv.stemmer,"stemmer-sv"),e.sv.stopWordFilter=e.generateStopWordFilter("alla allt att av blev bli blir blivit de dem den denna deras dess dessa det detta dig din dina ditt du där då efter ej eller en er era ert ett från för ha hade han hans har henne hennes hon honom hur här i icke ingen inom inte jag ju kan kunde man med mellan men mig min mina mitt mot mycket ni nu när någon något några och om oss på samma sedan sig sin sina sitta själv skulle som så sådan sådana sådant till under upp ut utan vad var vara varför varit varje vars vart vem vi vid vilka vilkas vilken vilket vår våra vårt än är åt över".split(" ")),e.Pipeline.registerFunction(e.sv.stopWordFilter,"stopWordFilter-sv")}});

assets/javascripts/lunr/min/lunr.ta.min.js

@@ -1 +0,0 @@
-!function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.ta=function(){this.pipeline.reset(),this.pipeline.add(e.ta.trimmer,e.ta.stopWordFilter,e.ta.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.ta.stemmer))},e.ta.wordCharacters="஀-உஊ-ஏஐ-ஙச-ட஠-னப-யர-ஹ஺-ிீ-௉ொ-௏ௐ-௙௚-௟௠-௩௪-௯௰-௹௺-௿a-zA-Zａ-ｚＡ-Ｚ0-9０-９",e.ta.trimmer=e.trimmerSupport.generateTrimmer(e.ta.wordCharacters),e.Pipeline.registerFunction(e.ta.trimmer,"trimmer-ta"),e.ta.stopWordFilter=e.generateStopWordFilter("அங்கு அங்கே அது அதை அந்த அவர் அவர்கள் அவள் அவன் அவை ஆக ஆகவே ஆகையால் ஆதலால் ஆதலினால் ஆனாலும் ஆனால் இங்கு இங்கே இது இதை இந்த இப்படி இவர் இவர்கள் இவள் இவன் இவை இவ்வளவு உனக்கு உனது உன் உன்னால் எங்கு எங்கே எது எதை எந்த எப்படி எவர் எவர்கள் எவள் எவன் எவை எவ்வளவு எனக்கு எனது எனவே என் என்ன என்னால் ஏது ஏன் தனது தன்னால் தானே தான் நாங்கள் நாம் நான் நீ நீங்கள்".split(" ")),e.ta.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var t=e.wordcut;t.init(),e.ta.tokenizer=function(r){if(!arguments.length||null==r||void 0==r)return[];if(Array.isArray(r))return r.map(function(t){return isLunr2?new e.Token(t.toLowerCase()):t.toLowerCase()});var i=r.toString().toLowerCase().replace(/^\s+/,"");return t.cut(i).split("|")},e.Pipeline.registerFunction(e.ta.stemmer,"stemmer-ta"),e.Pipeline.registerFunction(e.ta.stopWordFilter,"stopWordFilter-ta")}});

assets/javascripts/lunr/min/lunr.te.min.js

@@ -1 +0,0 @@
-!function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.te=function(){this.pipeline.reset(),this.pipeline.add(e.te.trimmer,e.te.stopWordFilter,e.te.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.te.stemmer))},e.te.wordCharacters="ఀ-ఄఅ-ఔక-హా-ౌౕ-ౖౘ-ౚౠ-ౡౢ-ౣ౦-౯౸-౿఼ఽ్ౝ౷౤౥",e.te.trimmer=e.trimmerSupport.generateTrimmer(e.te.wordCharacters),e.Pipeline.registerFunction(e.te.trimmer,"trimmer-te"),e.te.stopWordFilter=e.generateStopWordFilter("అందరూ అందుబాటులో అడగండి అడగడం అడ్డంగా అనుగుణంగా అనుమతించు అనుమతిస్తుంది అయితే ఇప్పటికే ఉన్నారు ఎక్కడైనా ఎప్పుడు ఎవరైనా ఎవరో ఏ ఏదైనా ఏమైనప్పటికి ఒక ఒకరు కనిపిస్తాయి కాదు కూడా గా గురించి చుట్టూ చేయగలిగింది తగిన తర్వాత దాదాపు దూరంగా నిజంగా పై ప్రకారం ప్రక్కన మధ్య మరియు మరొక మళ్ళీ మాత్రమే మెచ్చుకో వద్ద వెంట వేరుగా వ్యతిరేకంగా సంబంధం".split(" ")),e.te.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var t=e.wordcut;t.init(),e.te.tokenizer=function(r){if(!arguments.length||null==r||void 0==r)return[];if(Array.isArray(r))return r.map(function(t){return isLunr2?new e.Token(t.toLowerCase()):t.toLowerCase()});var i=r.toString().toLowerCase().replace(/^\s+/,"");return t.cut(i).split("|")},e.Pipeline.registerFunction(e.te.stemmer,"stemmer-te"),e.Pipeline.registerFunction(e.te.stopWordFilter,"stopWordFilter-te")}});

assets/javascripts/lunr/min/lunr.th.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");var r="2"==e.version[0];e.th=function(){this.pipeline.reset(),this.pipeline.add(e.th.trimmer),r?this.tokenizer=e.th.tokenizer:(e.tokenizer&&(e.tokenizer=e.th.tokenizer),this.tokenizerFn&&(this.tokenizerFn=e.th.tokenizer))},e.th.wordCharacters="[฀-๿]",e.th.trimmer=e.trimmerSupport.generateTrimmer(e.th.wordCharacters),e.Pipeline.registerFunction(e.th.trimmer,"trimmer-th");var t=e.wordcut;t.init(),e.th.tokenizer=function(i){if(!arguments.length||null==i||void 0==i)return[];if(Array.isArray(i))return i.map(function(t){return r?new e.Token(t):t});var n=i.toString().replace(/^\s+/,"");return t.cut(n).split("|")}}});

assets/javascripts/lunr/min/lunr.vi.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.vi=function(){this.pipeline.reset(),this.pipeline.add(e.vi.stopWordFilter,e.vi.trimmer)},e.vi.wordCharacters="[A-Za-ẓ̀͐́͑̉̃̓ÂâÊêÔôĂ-ăĐ-đƠ-ơƯ-ư]",e.vi.trimmer=e.trimmerSupport.generateTrimmer(e.vi.wordCharacters),e.Pipeline.registerFunction(e.vi.trimmer,"trimmer-vi"),e.vi.stopWordFilter=e.generateStopWordFilter("là cái nhưng mà".split(" "))}});

assets/javascripts/lunr/min/lunr.zh.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r(require("@node-rs/jieba")):r()(e.lunr)}(this,function(e){return function(r,t){if(void 0===r)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===r.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");var i="2"==r.version[0];r.zh=function(){this.pipeline.reset(),this.pipeline.add(r.zh.trimmer,r.zh.stopWordFilter,r.zh.stemmer),i?this.tokenizer=r.zh.tokenizer:(r.tokenizer&&(r.tokenizer=r.zh.tokenizer),this.tokenizerFn&&(this.tokenizerFn=r.zh.tokenizer))},r.zh.tokenizer=function(n){if(!arguments.length||null==n||void 0==n)return[];if(Array.isArray(n))return n.map(function(e){return i?new r.Token(e.toLowerCase()):e.toLowerCase()});t&&e.load(t);var o=n.toString().trim().toLowerCase(),s=[];e.cut(o,!0).forEach(function(e){s=s.concat(e.split(" "))}),s=s.filter(function(e){return!!e});var u=0;return s.map(function(e,t){if(i){var n=o.indexOf(e,u),s={};return s.position=[n,e.length],s.index=t,u=n,new r.Token(e,s)}return e})},r.zh.wordCharacters="\\w一-龥",r.zh.trimmer=r.trimmerSupport.generateTrimmer(r.zh.wordCharacters),r.Pipeline.registerFunction(r.zh.trimmer,"trimmer-zh"),r.zh.stemmer=function(){return function(e){return e}}(),r.Pipeline.registerFunction(r.zh.stemmer,"stemmer-zh"),r.zh.stopWordFilter=r.generateStopWordFilter("的 一 不 在 人 有 是 为 為 以 于 於 上 他 而 后 後 之 来 來 及 了 因 下 可 到 由 这 這 与 與 也 此 但 并 並 个 個 其 已 无 無 小 我 们 們 起 最 再 今 去 好 只 又 或 很 亦 某 把 那 你 乃 它 吧 被 比 别 趁 当 當 从 從 得 打 凡 儿 兒 尔 爾 该 該 各 给 給 跟 和 何 还 還 即 几 幾 既 看 据 據 距 靠 啦 另 么 麽 每 嘛 拿 哪 您 凭 憑 且 却 卻 让 讓 仍 啥 如 若 使 谁 誰 虽 雖 随 隨 同 所 她 哇 嗡 往 些 向 沿 哟 喲 用 咱 则 則 怎 曾 至 致 着 著 诸 諸 自".split(" ")),r.Pipeline.registerFunction(r.zh.stopWordFilter,"stopWordFilter-zh")}});

assets/javascripts/lunr/tinyseg.js

@@ -1,206 +0,0 @@
-/**
- * export the module via AMD, CommonJS or as a browser global
- * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
- */
-;(function (root, factory) {
-    if (typeof define === 'function' && define.amd) {
-        // AMD. Register as an anonymous module.
-        define(factory)
-    } else if (typeof exports === 'object') {
-        /**
-         * Node. Does not work with strict CommonJS, but
-         * only CommonJS-like environments that support module.exports,
-         * like Node.
-         */
-        module.exports = factory()
-    } else {
-        // Browser globals (root is window)
-        factory()(root.lunr);
-    }
-}(this, function () {
-    /**
-     * Just return a value to define the module export.
-     * This example returns an object, but the module
-     * can return a function as the exported value.
-     */
-
-    return function(lunr) {
-        // TinySegmenter 0.1 -- Super compact Japanese tokenizer in Javascript
-        // (c) 2008 Taku Kudo <taku@chasen.org>
-        // TinySegmenter is freely distributable under the terms of a new BSD licence.
-        // For details, see http://chasen.org/~taku/software/TinySegmenter/LICENCE.txt
-
-        function TinySegmenter() {
-          var patterns = {
-            "[一二三四五六七八九十百千万億兆]":"M",
-            "[一-龠々〆ヵヶ]":"H",
-            "[ぁ-ん]":"I",
-            "[ァ-ヴーｱ-ﾝﾞｰ]":"K",
-            "[a-zA-Zａ-ｚＡ-Ｚ]":"A",
-            "[0-9０-９]":"N"
-          }
-          this.chartype_ = [];
-          for (var i in patterns) {
-            var regexp = new RegExp(i);
-            this.chartype_.push([regexp, patterns[i]]);
-          }
-
-          this.BIAS__ = -332
-          this.BC1__ = {"HH":6,"II":2461,"KH":406,"OH":-1378};
-          this.BC2__ = {"AA":-3267,"AI":2744,"AN":-878,"HH":-4070,"HM":-1711,"HN":4012,"HO":3761,"IA":1327,"IH":-1184,"II":-1332,"IK":1721,"IO":5492,"KI":3831,"KK":-8741,"MH":-3132,"MK":3334,"OO":-2920};
-          this.BC3__ = {"HH":996,"HI":626,"HK":-721,"HN":-1307,"HO":-836,"IH":-301,"KK":2762,"MK":1079,"MM":4034,"OA":-1652,"OH":266};
-          this.BP1__ = {"BB":295,"OB":304,"OO":-125,"UB":352};
-          this.BP2__ = {"BO":60,"OO":-1762};
-          this.BQ1__ = {"BHH":1150,"BHM":1521,"BII":-1158,"BIM":886,"BMH":1208,"BNH":449,"BOH":-91,"BOO":-2597,"OHI":451,"OIH":-296,"OKA":1851,"OKH":-1020,"OKK":904,"OOO":2965};
-          this.BQ2__ = {"BHH":118,"BHI":-1159,"BHM":466,"BIH":-919,"BKK":-1720,"BKO":864,"OHH":-1139,"OHM":-181,"OIH":153,"UHI":-1146};
-          this.BQ3__ = {"BHH":-792,"BHI":2664,"BII":-299,"BKI":419,"BMH":937,"BMM":8335,"BNN":998,"BOH":775,"OHH":2174,"OHM":439,"OII":280,"OKH":1798,"OKI":-793,"OKO":-2242,"OMH":-2402,"OOO":11699};
-          this.BQ4__ = {"BHH":-3895,"BIH":3761,"BII":-4654,"BIK":1348,"BKK":-1806,"BMI":-3385,"BOO":-12396,"OAH":926,"OHH":266,"OHK":-2036,"ONN":-973};
-          this.BW1__ = {",と":660,",同":727,"B1あ":1404,"B1同":542,"、と":660,"、同":727,"」と":1682,"あっ":1505,"いう":1743,"いっ":-2055,"いる":672,"うし":-4817,"うん":665,"から":3472,"がら":600,"こう":-790,"こと":2083,"こん":-1262,"さら":-4143,"さん":4573,"した":2641,"して":1104,"すで":-3399,"そこ":1977,"それ":-871,"たち":1122,"ため":601,"った":3463,"つい":-802,"てい":805,"てき":1249,"でき":1127,"です":3445,"では":844,"とい":-4915,"とみ":1922,"どこ":3887,"ない":5713,"なっ":3015,"など":7379,"なん":-1113,"にし":2468,"には":1498,"にも":1671,"に対":-912,"の一":-501,"の中":741,"ませ":2448,"まで":1711,"まま":2600,"まる":-2155,"やむ":-1947,"よっ":-2565,"れた":2369,"れで":-913,"をし":1860,"を見":731,"亡く":-1886,"京都":2558,"取り":-2784,"大き":-2604,"大阪":1497,"平方":-2314,"引き":-1336,"日本":-195,"本当":-2423,"毎日":-2113,"目指":-724,"Ｂ１あ":1404,"Ｂ１同":542,"｣と":1682};
-          this.BW2__ = {"..":-11822,"11":-669,"――":-5730,"−−":-13175,"いう":-1609,"うか":2490,"かし":-1350,"かも":-602,"から":-7194,"かれ":4612,"がい":853,"がら":-3198,"きた":1941,"くな":-1597,"こと":-8392,"この":-4193,"させ":4533,"され":13168,"さん":-3977,"しい":-1819,"しか":-545,"した":5078,"して":972,"しな":939,"その":-3744,"たい":-1253,"たた":-662,"ただ":-3857,"たち":-786,"たと":1224,"たは":-939,"った":4589,"って":1647,"っと":-2094,"てい":6144,"てき":3640,"てく":2551,"ては":-3110,"ても":-3065,"でい":2666,"でき":-1528,"でし":-3828,"です":-4761,"でも":-4203,"とい":1890,"とこ":-1746,"とと":-2279,"との":720,"とみ":5168,"とも":-3941,"ない":-2488,"なが":-1313,"など":-6509,"なの":2614,"なん":3099,"にお":-1615,"にし":2748,"にな":2454,"によ":-7236,"に対":-14943,"に従":-4688,"に関":-11388,"のか":2093,"ので":-7059,"のに":-6041,"のの":-6125,"はい":1073,"はが":-1033,"はず":-2532,"ばれ":1813,"まし":-1316,"まで":-6621,"まれ":5409,"めて":-3153,"もい":2230,"もの":-10713,"らか":-944,"らし":-1611,"らに":-1897,"りし":651,"りま":1620,"れた":4270,"れて":849,"れば":4114,"ろう":6067,"われ":7901,"を通":-11877,"んだ":728,"んな":-4115,"一人":602,"一方":-1375,"一日":970,"一部":-1051,"上が":-4479,"会社":-1116,"出て":2163,"分の":-7758,"同党":970,"同日":-913,"大阪":-2471,"委員":-1250,"少な":-1050,"年度":-8669,"年間":-1626,"府県":-2363,"手権":-1982,"新聞":-4066,"日新":-722,"日本":-7068,"日米":3372,"曜日":-601,"朝鮮":-2355,"本人":-2697,"東京":-1543,"然と":-1384,"社会":-1276,"立て":-990,"第に":-1612,"米国":-4268,"１１":-669};
-          this.BW3__ = {"あた":-2194,"あり":719,"ある":3846,"い.":-1185,"い。":-1185,"いい":5308,"いえ":2079,"いく":3029,"いた":2056,"いっ":1883,"いる":5600,"いわ":1527,"うち":1117,"うと":4798,"えと":1454,"か.":2857,"か。":2857,"かけ":-743,"かっ":-4098,"かに":-669,"から":6520,"かり":-2670,"が,":1816,"が、":1816,"がき":-4855,"がけ":-1127,"がっ":-913,"がら":-4977,"がり":-2064,"きた":1645,"けど":1374,"こと":7397,"この":1542,"ころ":-2757,"さい":-714,"さを":976,"し,":1557,"し、":1557,"しい":-3714,"した":3562,"して":1449,"しな":2608,"しま":1200,"す.":-1310,"す。":-1310,"する":6521,"ず,":3426,"ず、":3426,"ずに":841,"そう":428,"た.":8875,"た。":8875,"たい":-594,"たの":812,"たり":-1183,"たる":-853,"だ.":4098,"だ。":4098,"だっ":1004,"った":-4748,"って":300,"てい":6240,"てお":855,"ても":302,"です":1437,"でに":-1482,"では":2295,"とう":-1387,"とし":2266,"との":541,"とも":-3543,"どう":4664,"ない":1796,"なく":-903,"など":2135,"に,":-1021,"に、":-1021,"にし":1771,"にな":1906,"には":2644,"の,":-724,"の、":-724,"の子":-1000,"は,":1337,"は、":1337,"べき":2181,"まし":1113,"ます":6943,"まっ":-1549,"まで":6154,"まれ":-793,"らし":1479,"られ":6820,"るる":3818,"れ,":854,"れ、":854,"れた":1850,"れて":1375,"れば":-3246,"れる":1091,"われ":-605,"んだ":606,"んで":798,"カ月":990,"会議":860,"入り":1232,"大会":2217,"始め":1681,"市":965,"新聞":-5055,"日,":974,"日、":974,"社会":2024,"ｶ月":990};
-          this.TC1__ = {"AAA":1093,"HHH":1029,"HHM":580,"HII":998,"HOH":-390,"HOM":-331,"IHI":1169,"IOH":-142,"IOI":-1015,"IOM":467,"MMH":187,"OOI":-1832};
-          this.TC2__ = {"HHO":2088,"HII":-1023,"HMM":-1154,"IHI":-1965,"KKH":703,"OII":-2649};
-          this.TC3__ = {"AAA":-294,"HHH":346,"HHI":-341,"HII":-1088,"HIK":731,"HOH":-1486,"IHH":128,"IHI":-3041,"IHO":-1935,"IIH":-825,"IIM":-1035,"IOI":-542,"KHH":-1216,"KKA":491,"KKH":-1217,"KOK":-1009,"MHH":-2694,"MHM":-457,"MHO":123,"MMH":-471,"NNH":-1689,"NNO":662,"OHO":-3393};
-          this.TC4__ = {"HHH":-203,"HHI":1344,"HHK":365,"HHM":-122,"HHN":182,"HHO":669,"HIH":804,"HII":679,"HOH":446,"IHH":695,"IHO":-2324,"IIH":321,"III":1497,"IIO":656,"IOO":54,"KAK":4845,"KKA":3386,"KKK":3065,"MHH":-405,"MHI":201,"MMH":-241,"MMM":661,"MOM":841};
-          this.TQ1__ = {"BHHH":-227,"BHHI":316,"BHIH":-132,"BIHH":60,"BIII":1595,"BNHH":-744,"BOHH":225,"BOOO":-908,"OAKK":482,"OHHH":281,"OHIH":249,"OIHI":200,"OIIH":-68};
-          this.TQ2__ = {"BIHH":-1401,"BIII":-1033,"BKAK":-543,"BOOO":-5591};
-          this.TQ3__ = {"BHHH":478,"BHHM":-1073,"BHIH":222,"BHII":-504,"BIIH":-116,"BIII":-105,"BMHI":-863,"BMHM":-464,"BOMH":620,"OHHH":346,"OHHI":1729,"OHII":997,"OHMH":481,"OIHH":623,"OIIH":1344,"OKAK":2792,"OKHH":587,"OKKA":679,"OOHH":110,"OOII":-685};
-          this.TQ4__ = {"BHHH":-721,"BHHM":-3604,"BHII":-966,"BIIH":-607,"BIII":-2181,"OAAA":-2763,"OAKK":180,"OHHH":-294,"OHHI":2446,"OHHO":480,"OHIH":-1573,"OIHH":1935,"OIHI":-493,"OIIH":626,"OIII":-4007,"OKAK":-8156};
-          this.TW1__ = {"につい":-4681,"東京都":2026};
-          this.TW2__ = {"ある程":-2049,"いった":-1256,"ころが":-2434,"しょう":3873,"その後":-4430,"だって":-1049,"ていた":1833,"として":-4657,"ともに":-4517,"もので":1882,"一気に":-792,"初めて":-1512,"同時に":-8097,"大きな":-1255,"対して":-2721,"社会党":-3216};
-          this.TW3__ = {"いただ":-1734,"してい":1314,"として":-4314,"につい":-5483,"にとっ":-5989,"に当た":-6247,"ので,":-727,"ので、":-727,"のもの":-600,"れから":-3752,"十二月":-2287};
-          this.TW4__ = {"いう.":8576,"いう。":8576,"からな":-2348,"してい":2958,"たが,":1516,"たが、":1516,"ている":1538,"という":1349,"ました":5543,"ません":1097,"ようと":-4258,"よると":5865};
-          this.UC1__ = {"A":484,"K":93,"M":645,"O":-505};
-          this.UC2__ = {"A":819,"H":1059,"I":409,"M":3987,"N":5775,"O":646};
-          this.UC3__ = {"A":-1370,"I":2311};
-          this.UC4__ = {"A":-2643,"H":1809,"I":-1032,"K":-3450,"M":3565,"N":3876,"O":6646};
-          this.UC5__ = {"H":313,"I":-1238,"K":-799,"M":539,"O":-831};
-          this.UC6__ = {"H":-506,"I":-253,"K":87,"M":247,"O":-387};
-          this.UP1__ = {"O":-214};
-          this.UP2__ = {"B":69,"O":935};
-          this.UP3__ = {"B":189};
-          this.UQ1__ = {"BH":21,"BI":-12,"BK":-99,"BN":142,"BO":-56,"OH":-95,"OI":477,"OK":410,"OO":-2422};
-          this.UQ2__ = {"BH":216,"BI":113,"OK":1759};
-          this.UQ3__ = {"BA":-479,"BH":42,"BI":1913,"BK":-7198,"BM":3160,"BN":6427,"BO":14761,"OI":-827,"ON":-3212};
-          this.UW1__ = {",":156,"、":156,"「":-463,"あ":-941,"う":-127,"が":-553,"き":121,"こ":505,"で":-201,"と":-547,"ど":-123,"に":-789,"の":-185,"は":-847,"も":-466,"や":-470,"よ":182,"ら":-292,"り":208,"れ":169,"を":-446,"ん":-137,"・":-135,"主":-402,"京":-268,"区":-912,"午":871,"国":-460,"大":561,"委":729,"市":-411,"日":-141,"理":361,"生":-408,"県":-386,"都":-718,"｢":-463,"･":-135};
-          this.UW2__ = {",":-829,"、":-829,"〇":892,"「":-645,"」":3145,"あ":-538,"い":505,"う":134,"お":-502,"か":1454,"が":-856,"く":-412,"こ":1141,"さ":878,"ざ":540,"し":1529,"す":-675,"せ":300,"そ":-1011,"た":188,"だ":1837,"つ":-949,"て":-291,"で":-268,"と":-981,"ど":1273,"な":1063,"に":-1764,"の":130,"は":-409,"ひ":-1273,"べ":1261,"ま":600,"も":-1263,"や":-402,"よ":1639,"り":-579,"る":-694,"れ":571,"を":-2516,"ん":2095,"ア":-587,"カ":306,"キ":568,"ッ":831,"三":-758,"不":-2150,"世":-302,"中":-968,"主":-861,"事":492,"人":-123,"会":978,"保":362,"入":548,"初":-3025,"副":-1566,"北":-3414,"区":-422,"大":-1769,"天":-865,"太":-483,"子":-1519,"学":760,"実":1023,"小":-2009,"市":-813,"年":-1060,"強":1067,"手":-1519,"揺":-1033,"政":1522,"文":-1355,"新":-1682,"日":-1815,"明":-1462,"最":-630,"朝":-1843,"本":-1650,"東":-931,"果":-665,"次":-2378,"民":-180,"気":-1740,"理":752,"発":529,"目":-1584,"相":-242,"県":-1165,"立":-763,"第":810,"米":509,"自":-1353,"行":838,"西":-744,"見":-3874,"調":1010,"議":1198,"込":3041,"開":1758,"間":-1257,"｢":-645,"｣":3145,"ｯ":831,"ｱ":-587,"ｶ":306,"ｷ":568};
-          this.UW3__ = {",":4889,"1":-800,"−":-1723,"、":4889,"々":-2311,"〇":5827,"」":2670,"〓":-3573,"あ":-2696,"い":1006,"う":2342,"え":1983,"お":-4864,"か":-1163,"が":3271,"く":1004,"け":388,"げ":401,"こ":-3552,"ご":-3116,"さ":-1058,"し":-395,"す":584,"せ":3685,"そ":-5228,"た":842,"ち":-521,"っ":-1444,"つ":-1081,"て":6167,"で":2318,"と":1691,"ど":-899,"な":-2788,"に":2745,"の":4056,"は":4555,"ひ":-2171,"ふ":-1798,"へ":1199,"ほ":-5516,"ま":-4384,"み":-120,"め":1205,"も":2323,"や":-788,"よ":-202,"ら":727,"り":649,"る":5905,"れ":2773,"わ":-1207,"を":6620,"ん":-518,"ア":551,"グ":1319,"ス":874,"ッ":-1350,"ト":521,"ム":1109,"ル":1591,"ロ":2201,"ン":278,"・":-3794,"一":-1619,"下":-1759,"世":-2087,"両":3815,"中":653,"主":-758,"予":-1193,"二":974,"人":2742,"今":792,"他":1889,"以":-1368,"低":811,"何":4265,"作":-361,"保":-2439,"元":4858,"党":3593,"全":1574,"公":-3030,"六":755,"共":-1880,"円":5807,"再":3095,"分":457,"初":2475,"別":1129,"前":2286,"副":4437,"力":365,"動":-949,"務":-1872,"化":1327,"北":-1038,"区":4646,"千":-2309,"午":-783,"協":-1006,"口":483,"右":1233,"各":3588,"合":-241,"同":3906,"和":-837,"員":4513,"国":642,"型":1389,"場":1219,"外":-241,"妻":2016,"学":-1356,"安":-423,"実":-1008,"家":1078,"小":-513,"少":-3102,"州":1155,"市":3197,"平":-1804,"年":2416,"広":-1030,"府":1605,"度":1452,"建":-2352,"当":-3885,"得":1905,"思":-1291,"性":1822,"戸":-488,"指":-3973,"政":-2013,"教":-1479,"数":3222,"文":-1489,"新":1764,"日":2099,"旧":5792,"昨":-661,"時":-1248,"曜":-951,"最":-937,"月":4125,"期":360,"李":3094,"村":364,"東":-805,"核":5156,"森":2438,"業":484,"氏":2613,"民":-1694,"決":-1073,"法":1868,"海":-495,"無":979,"物":461,"特":-3850,"生":-273,"用":914,"町":1215,"的":7313,"直":-1835,"省":792,"県":6293,"知":-1528,"私":4231,"税":401,"立":-960,"第":1201,"米":7767,"系":3066,"約":3663,"級":1384,"統":-4229,"総":1163,"線":1255,"者":6457,"能":725,"自":-2869,"英":785,"見":1044,"調":-562,"財":-733,"費":1777,"車":1835,"軍":1375,"込":-1504,"通":-1136,"選":-681,"郎":1026,"郡":4404,"部":1200,"金":2163,"長":421,"開":-1432,"間":1302,"関":-1282,"雨":2009,"電":-1045,"非":2066,"駅":1620,"１":-800,"｣":2670,"･":-3794,"ｯ":-1350,"ｱ":551,"ｸﾞ":1319,"ｽ":874,"ﾄ":521,"ﾑ":1109,"ﾙ":1591,"ﾛ":2201,"ﾝ":278};
-          this.UW4__ = {",":3930,".":3508,"―":-4841,"、":3930,"。":3508,"〇":4999,"「":1895,"」":3798,"〓":-5156,"あ":4752,"い":-3435,"う":-640,"え":-2514,"お":2405,"か":530,"が":6006,"き":-4482,"ぎ":-3821,"く":-3788,"け":-4376,"げ":-4734,"こ":2255,"ご":1979,"さ":2864,"し":-843,"じ":-2506,"す":-731,"ず":1251,"せ":181,"そ":4091,"た":5034,"だ":5408,"ち":-3654,"っ":-5882,"つ":-1659,"て":3994,"で":7410,"と":4547,"な":5433,"に":6499,"ぬ":1853,"ね":1413,"の":7396,"は":8578,"ば":1940,"ひ":4249,"び":-4134,"ふ":1345,"へ":6665,"べ":-744,"ほ":1464,"ま":1051,"み":-2082,"む":-882,"め":-5046,"も":4169,"ゃ":-2666,"や":2795,"ょ":-1544,"よ":3351,"ら":-2922,"り":-9726,"る":-14896,"れ":-2613,"ろ":-4570,"わ":-1783,"を":13150,"ん":-2352,"カ":2145,"コ":1789,"セ":1287,"ッ":-724,"ト":-403,"メ":-1635,"ラ":-881,"リ":-541,"ル":-856,"ン":-3637,"・":-4371,"ー":-11870,"一":-2069,"中":2210,"予":782,"事":-190,"井":-1768,"人":1036,"以":544,"会":950,"体":-1286,"作":530,"側":4292,"先":601,"党":-2006,"共":-1212,"内":584,"円":788,"初":1347,"前":1623,"副":3879,"力":-302,"動":-740,"務":-2715,"化":776,"区":4517,"協":1013,"参":1555,"合":-1834,"和":-681,"員":-910,"器":-851,"回":1500,"国":-619,"園":-1200,"地":866,"場":-1410,"塁":-2094,"士":-1413,"多":1067,"大":571,"子":-4802,"学":-1397,"定":-1057,"寺":-809,"小":1910,"屋":-1328,"山":-1500,"島":-2056,"川":-2667,"市":2771,"年":374,"庁":-4556,"後":456,"性":553,"感":916,"所":-1566,"支":856,"改":787,"政":2182,"教":704,"文":522,"方":-856,"日":1798,"時":1829,"最":845,"月":-9066,"木":-485,"来":-442,"校":-360,"業":-1043,"氏":5388,"民":-2716,"気":-910,"沢":-939,"済":-543,"物":-735,"率":672,"球":-1267,"生":-1286,"産":-1101,"田":-2900,"町":1826,"的":2586,"目":922,"省":-3485,"県":2997,"空":-867,"立":-2112,"第":788,"米":2937,"系":786,"約":2171,"経":1146,"統":-1169,"総":940,"線":-994,"署":749,"者":2145,"能":-730,"般":-852,"行":-792,"規":792,"警":-1184,"議":-244,"谷":-1000,"賞":730,"車":-1481,"軍":1158,"輪":-1433,"込":-3370,"近":929,"道":-1291,"選":2596,"郎":-4866,"都":1192,"野":-1100,"銀":-2213,"長":357,"間":-2344,"院":-2297,"際":-2604,"電":-878,"領":-1659,"題":-792,"館":-1984,"首":1749,"高":2120,"｢":1895,"｣":3798,"･":-4371,"ｯ":-724,"ｰ":-11870,"ｶ":2145,"ｺ":1789,"ｾ":1287,"ﾄ":-403,"ﾒ":-1635,"ﾗ":-881,"ﾘ":-541,"ﾙ":-856,"ﾝ":-3637};
-          this.UW5__ = {",":465,".":-299,"1":-514,"E2":-32768,"]":-2762,"、":465,"。":-299,"「":363,"あ":1655,"い":331,"う":-503,"え":1199,"お":527,"か":647,"が":-421,"き":1624,"ぎ":1971,"く":312,"げ":-983,"さ":-1537,"し":-1371,"す":-852,"だ":-1186,"ち":1093,"っ":52,"つ":921,"て":-18,"で":-850,"と":-127,"ど":1682,"な":-787,"に":-1224,"の":-635,"は":-578,"べ":1001,"み":502,"め":865,"ゃ":3350,"ょ":854,"り":-208,"る":429,"れ":504,"わ":419,"を":-1264,"ん":327,"イ":241,"ル":451,"ン":-343,"中":-871,"京":722,"会":-1153,"党":-654,"務":3519,"区":-901,"告":848,"員":2104,"大":-1296,"学":-548,"定":1785,"嵐":-1304,"市":-2991,"席":921,"年":1763,"思":872,"所":-814,"挙":1618,"新":-1682,"日":218,"月":-4353,"査":932,"格":1356,"機":-1508,"氏":-1347,"田":240,"町":-3912,"的":-3149,"相":1319,"省":-1052,"県":-4003,"研":-997,"社":-278,"空":-813,"統":1955,"者":-2233,"表":663,"語":-1073,"議":1219,"選":-1018,"郎":-368,"長":786,"間":1191,"題":2368,"館":-689,"１":-514,"Ｅ２":-32768,"｢":363,"ｲ":241,"ﾙ":451,"ﾝ":-343};
-          this.UW6__ = {",":227,".":808,"1":-270,"E1":306,"、":227,"。":808,"あ":-307,"う":189,"か":241,"が":-73,"く":-121,"こ":-200,"じ":1782,"す":383,"た":-428,"っ":573,"て":-1014,"で":101,"と":-105,"な":-253,"に":-149,"の":-417,"は":-236,"も":-206,"り":187,"る":-135,"を":195,"ル":-673,"ン":-496,"一":-277,"中":201,"件":-800,"会":624,"前":302,"区":1792,"員":-1212,"委":798,"学":-960,"市":887,"広":-695,"後":535,"業":-697,"相":753,"社":-507,"福":974,"空":-822,"者":1811,"連":463,"郎":1082,"１":-270,"Ｅ１":306,"ﾙ":-673,"ﾝ":-496};
-          
-          return this;
-        }
-        TinySegmenter.prototype.ctype_ = function(str) {
-          for (var i in this.chartype_) {
-            if (str.match(this.chartype_[i][0])) {
-              return this.chartype_[i][1];
-            }
-          }
-          return "O";
-        }
-
-        TinySegmenter.prototype.ts_ = function(v) {
-          if (v) { return v; }
-          return 0;
-        }
-
-        TinySegmenter.prototype.segment = function(input) {
-          if (input == null || input == undefined || input == "") {
-            return [];
-          }
-          var result = [];
-          var seg = ["B3","B2","B1"];
-          var ctype = ["O","O","O"];
-          var o = input.split("");
-          for (i = 0; i < o.length; ++i) {
-            seg.push(o[i]);
-            ctype.push(this.ctype_(o[i]))
-          }
-          seg.push("E1");
-          seg.push("E2");
-          seg.push("E3");
-          ctype.push("O");
-          ctype.push("O");
-          ctype.push("O");
-          var word = seg[3];
-          var p1 = "U";
-          var p2 = "U";
-          var p3 = "U";
-          for (var i = 4; i < seg.length - 3; ++i) {
-            var score = this.BIAS__;
-            var w1 = seg[i-3];
-            var w2 = seg[i-2];
-            var w3 = seg[i-1];
-            var w4 = seg[i];
-            var w5 = seg[i+1];
-            var w6 = seg[i+2];
-            var c1 = ctype[i-3];
-            var c2 = ctype[i-2];
-            var c3 = ctype[i-1];
-            var c4 = ctype[i];
-            var c5 = ctype[i+1];
-            var c6 = ctype[i+2];
-            score += this.ts_(this.UP1__[p1]);
-            score += this.ts_(this.UP2__[p2]);
-            score += this.ts_(this.UP3__[p3]);
-            score += this.ts_(this.BP1__[p1 + p2]);
-            score += this.ts_(this.BP2__[p2 + p3]);
-            score += this.ts_(this.UW1__[w1]);
-            score += this.ts_(this.UW2__[w2]);
-            score += this.ts_(this.UW3__[w3]);
-            score += this.ts_(this.UW4__[w4]);
-            score += this.ts_(this.UW5__[w5]);
-            score += this.ts_(this.UW6__[w6]);
-            score += this.ts_(this.BW1__[w2 + w3]);
-            score += this.ts_(this.BW2__[w3 + w4]);
-            score += this.ts_(this.BW3__[w4 + w5]);
-            score += this.ts_(this.TW1__[w1 + w2 + w3]);
-            score += this.ts_(this.TW2__[w2 + w3 + w4]);
-            score += this.ts_(this.TW3__[w3 + w4 + w5]);
-            score += this.ts_(this.TW4__[w4 + w5 + w6]);
-            score += this.ts_(this.UC1__[c1]);
-            score += this.ts_(this.UC2__[c2]);
-            score += this.ts_(this.UC3__[c3]);
-            score += this.ts_(this.UC4__[c4]);
-            score += this.ts_(this.UC5__[c5]);
-            score += this.ts_(this.UC6__[c6]);
-            score += this.ts_(this.BC1__[c2 + c3]);
-            score += this.ts_(this.BC2__[c3 + c4]);
-            score += this.ts_(this.BC3__[c4 + c5]);
-            score += this.ts_(this.TC1__[c1 + c2 + c3]);
-            score += this.ts_(this.TC2__[c2 + c3 + c4]);
-            score += this.ts_(this.TC3__[c3 + c4 + c5]);
-            score += this.ts_(this.TC4__[c4 + c5 + c6]);
-        //  score += this.ts_(this.TC5__[c4 + c5 + c6]);    
-            score += this.ts_(this.UQ1__[p1 + c1]);
-            score += this.ts_(this.UQ2__[p2 + c2]);
-            score += this.ts_(this.UQ3__[p3 + c3]);
-            score += this.ts_(this.BQ1__[p2 + c2 + c3]);
-            score += this.ts_(this.BQ2__[p2 + c3 + c4]);
-            score += this.ts_(this.BQ3__[p3 + c2 + c3]);
-            score += this.ts_(this.BQ4__[p3 + c3 + c4]);
-            score += this.ts_(this.TQ1__[p2 + c1 + c2 + c3]);
-            score += this.ts_(this.TQ2__[p2 + c2 + c3 + c4]);
-            score += this.ts_(this.TQ3__[p3 + c1 + c2 + c3]);
-            score += this.ts_(this.TQ4__[p3 + c2 + c3 + c4]);
-            var p = "O";
-            if (score > 0) {
-              result.push(word);
-              word = "";
-              p = "B";
-            }
-            p1 = p2;
-            p2 = p3;
-            p3 = p;
-            word += seg[i];
-          }
-          result.push(word);
-
-          return result;
-        }
-
-        lunr.TinySegmenter = TinySegmenter;
-    };
-
-}));

assets/stylesheets/palette.ab4e12ef.min.css.map

@@ -1 +0,0 @@
-{"version":3,"sources":["src/templates/assets/stylesheets/palette/_scheme.scss","../../../../src/templates/assets/stylesheets/palette.scss","src/templates/assets/stylesheets/palette/_accent.scss","src/templates/assets/stylesheets/palette/_primary.scss","src/templates/assets/stylesheets/utilities/_break.scss"],"names":[],"mappings":"AA2BA,cAGE,6BAME,sDAAA,CACA,6DAAA,CACA,+DAAA,CACA,gEAAA,CACA,mDAAA,CACA,6DAAA,CACA,+DAAA,CACA,gEAAA,CAGA,mDAAA,CACA,gDAAA,CACA,yDAAA,CACA,4DAAA,CAGA,0BAAA,CACA,mCAAA,CAGA,iCAAA,CACA,kCAAA,CACA,mCAAA,CACA,mCAAA,CACA,kCAAA,CACA,iCAAA,CACA,+CAAA,CACA,6DAAA,CACA,gEAAA,CACA,4DAAA,CACA,4DAAA,CACA,6DAAA,CAGA,6CAAA,CAGA,+CAAA,CAGA,uDAAA,CACA,6DAAA,CACA,2DAAA,CAGA,iCAAA,CAGA,yDAAA,CACA,iEAAA,CAGA,mDAAA,CACA,mDAAA,CAGA,qDAAA,CACA,uDAAA,CAGA,8DAAA,CAKA,8DAAA,CAKA,0DAAA,CAzEA,iBCiBF,CD6DE,kHAEE,YC3DJ,CDkFE,yDACE,4BChFJ,CD+EE,2DACE,4BC7EJ,CD4EE,gEACE,4BC1EJ,CDyEE,2DACE,4BCvEJ,CDsEE,yDACE,4BCpEJ,CDmEE,0DACE,4BCjEJ,CDgEE,gEACE,4BC9DJ,CD6DE,0DACE,4BC3DJ,CD0DE,2OACE,4BC/CJ,CDsDA,+FAGE,iCCpDF,CACF,CCjDE,2BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD6CN,CCvDE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDoDN,CC9DE,8BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD2DN,CCrEE,mCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDkEN,CC5EE,8BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDyEN,CCnFE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDgFN,CC1FE,kCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDuFN,CCjGE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD8FN,CCxGE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDqGN,CC/GE,6BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD4GN,CCtHE,mCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDmHN,CC7HE,4BACE,4BAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCD6HN,CCpIE,8BACE,4BAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCDoIN,CC3IE,6BACE,yBAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCD2IN,CClJE,8BACE,4BAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCDkJN,CCzJE,mCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDsJN,CE3JE,4BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwJN,CEnKE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFgKN,CE3KE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwKN,CEnLE,oCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFgLN,CE3LE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwLN,CEnME,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFgMN,CE3ME,mCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwMN,CEnNE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFgNN,CE3NE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwNN,CEnOE,8BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFgON,CE3OE,oCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwON,CEnPE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCFmPN,CE3PE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCF2PN,CEnQE,8BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCFmQN,CE3QE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCF2QN,CEnRE,oCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFgRN,CE3RE,8BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFwRN,CEnSE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCAAA,CAKA,4BF4RN,CE5SE,kCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCAAA,CAKA,4BFqSN,CEtRE,sEACE,4BFyRJ,CE1RE,+DACE,4BF6RJ,CE9RE,iEACE,4BFiSJ,CElSE,gEACE,4BFqSJ,CEtSE,iEACE,4BFySJ,CEhSA,8BACE,mDAAA,CACA,4DAAA,CACA,0DAAA,CACA,oDAAA,CACA,2DAAA,CAGA,4BFiSF,CE9RE,yCACE,+BFgSJ,CE7RI,kDAEE,0CAAA,CACA,sCAAA,CAFA,mCFiSN,CG7MI,mCD1EA,+CACE,8CF0RJ,CEvRI,qDACE,8CFyRN,CEpRE,iEACE,mCFsRJ,CACF,CGxNI,sCDvDA,uCACE,oCFkRJ,CACF,CEzQA,8BACE,kDAAA,CACA,4DAAA,CACA,wDAAA,CACA,oDAAA,CACA,6DAAA,CAGA,4BF0QF,CEvQE,yCACE,+BFyQJ,CEtQI,kDAEE,0CAAA,CACA,sCAAA,CAFA,mCF0QN,CEnQE,yCACE,6CFqQJ,CG9NI,0CDhCA,8CACE,gDFiQJ,CACF,CGnOI,0CDvBA,iFACE,6CF6PJ,CACF,CG3PI,sCDKA,uCACE,6CFyPJ,CACF","file":"palette.css"}

bumble/__init__.py

@@ -0,0 +1,4 @@
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown version"

bumble/a2dp.py

@@ -0,0 +1,604 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+import logging
+from collections import namedtuple
+import bitstruct
+
+from .company_ids import COMPANY_IDENTIFIERS
+from .sdp import (
+    DataElement,
+    ServiceAttribute,
+    SDP_PUBLIC_BROWSE_ROOT,
+    SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+)
+from .core import (
+    BT_L2CAP_PROTOCOL_ID,
+    BT_AUDIO_SOURCE_SERVICE,
+    BT_AUDIO_SINK_SERVICE,
+    BT_AVDTP_PROTOCOL_ID,
+    BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE,
+    name_or_number,
+)
+
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+# fmt: off
+
+A2DP_SBC_CODEC_TYPE            = 0x00
+A2DP_MPEG_1_2_AUDIO_CODEC_TYPE = 0x01
+A2DP_MPEG_2_4_AAC_CODEC_TYPE   = 0x02
+A2DP_ATRAC_FAMILY_CODEC_TYPE   = 0x03
+A2DP_NON_A2DP_CODEC_TYPE       = 0xFF
+
+A2DP_CODEC_TYPE_NAMES = {
+    A2DP_SBC_CODEC_TYPE:            'A2DP_SBC_CODEC_TYPE',
+    A2DP_MPEG_1_2_AUDIO_CODEC_TYPE: 'A2DP_MPEG_1_2_AUDIO_CODEC_TYPE',
+    A2DP_MPEG_2_4_AAC_CODEC_TYPE:   'A2DP_MPEG_2_4_AAC_CODEC_TYPE',
+    A2DP_ATRAC_FAMILY_CODEC_TYPE:   'A2DP_ATRAC_FAMILY_CODEC_TYPE',
+    A2DP_NON_A2DP_CODEC_TYPE:       'A2DP_NON_A2DP_CODEC_TYPE'
+}
+
+
+SBC_SYNC_WORD = 0x9C
+
+SBC_SAMPLING_FREQUENCIES = [
+    16000,
+    22050,
+    44100,
+    48000
+]
+
+SBC_MONO_CHANNEL_MODE         = 0x00
+SBC_DUAL_CHANNEL_MODE         = 0x01
+SBC_STEREO_CHANNEL_MODE       = 0x02
+SBC_JOINT_STEREO_CHANNEL_MODE = 0x03
+
+SBC_CHANNEL_MODE_NAMES = {
+    SBC_MONO_CHANNEL_MODE:         'SBC_MONO_CHANNEL_MODE',
+    SBC_DUAL_CHANNEL_MODE:         'SBC_DUAL_CHANNEL_MODE',
+    SBC_STEREO_CHANNEL_MODE:       'SBC_STEREO_CHANNEL_MODE',
+    SBC_JOINT_STEREO_CHANNEL_MODE: 'SBC_JOINT_STEREO_CHANNEL_MODE'
+}
+
+SBC_BLOCK_LENGTHS = [4, 8, 12, 16]
+
+SBC_SUBBANDS = [4, 8]
+
+SBC_SNR_ALLOCATION_METHOD      = 0x00
+SBC_LOUDNESS_ALLOCATION_METHOD = 0x01
+
+SBC_ALLOCATION_METHOD_NAMES = {
+    SBC_SNR_ALLOCATION_METHOD:      'SBC_SNR_ALLOCATION_METHOD',
+    SBC_LOUDNESS_ALLOCATION_METHOD: 'SBC_LOUDNESS_ALLOCATION_METHOD'
+}
+
+MPEG_2_4_AAC_SAMPLING_FREQUENCIES = [
+    8000,
+    11025,
+    12000,
+    16000,
+    22050,
+    24000,
+    32000,
+    44100,
+    48000,
+    64000,
+    88200,
+    96000
+]
+
+MPEG_2_AAC_LC_OBJECT_TYPE       = 0x00
+MPEG_4_AAC_LC_OBJECT_TYPE       = 0x01
+MPEG_4_AAC_LTP_OBJECT_TYPE      = 0x02
+MPEG_4_AAC_SCALABLE_OBJECT_TYPE = 0x03
+
+MPEG_2_4_OBJECT_TYPE_NAMES = {
+    MPEG_2_AAC_LC_OBJECT_TYPE:       'MPEG_2_AAC_LC_OBJECT_TYPE',
+    MPEG_4_AAC_LC_OBJECT_TYPE:       'MPEG_4_AAC_LC_OBJECT_TYPE',
+    MPEG_4_AAC_LTP_OBJECT_TYPE:      'MPEG_4_AAC_LTP_OBJECT_TYPE',
+    MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 'MPEG_4_AAC_SCALABLE_OBJECT_TYPE'
+}
+
+# fmt: on
+
+
+# -----------------------------------------------------------------------------
+def flags_to_list(flags, values):
+    result = []
+    for i, value in enumerate(values):
+        if flags & (1 << (len(values) - i - 1)):
+            result.append(value)
+    return result
+
+
+# -----------------------------------------------------------------------------
+def make_audio_source_service_sdp_records(service_record_handle, version=(1, 3)):
+    # pylint: disable=import-outside-toplevel
+    from .avdtp import AVDTP_PSM
+
+    version_int = version[0] << 8 | version[1]
+    return [
+        ServiceAttribute(
+            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+            DataElement.unsigned_integer_32(service_record_handle),
+        ),
+        ServiceAttribute(
+            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
+        ),
+        ServiceAttribute(
+            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+            DataElement.sequence([DataElement.uuid(BT_AUDIO_SOURCE_SERVICE)]),
+        ),
+        ServiceAttribute(
+            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            DataElement.sequence(
+                [
+                    DataElement.sequence(
+                        [
+                            DataElement.uuid(BT_L2CAP_PROTOCOL_ID),
+                            DataElement.unsigned_integer_16(AVDTP_PSM),
+                        ]
+                    ),
+                    DataElement.sequence(
+                        [
+                            DataElement.uuid(BT_AVDTP_PROTOCOL_ID),
+                            DataElement.unsigned_integer_16(version_int),
+                        ]
+                    ),
+                ]
+            ),
+        ),
+        ServiceAttribute(
+            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            DataElement.sequence(
+                [
+                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                    DataElement.unsigned_integer_16(version_int),
+                ]
+            ),
+        ),
+    ]
+
+
+# -----------------------------------------------------------------------------
+def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
+    # pylint: disable=import-outside-toplevel
+    from .avdtp import AVDTP_PSM
+
+    version_int = version[0] << 8 | version[1]
+    return [
+        ServiceAttribute(
+            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+            DataElement.unsigned_integer_32(service_record_handle),
+        ),
+        ServiceAttribute(
+            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
+        ),
+        ServiceAttribute(
+            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+            DataElement.sequence([DataElement.uuid(BT_AUDIO_SINK_SERVICE)]),
+        ),
+        ServiceAttribute(
+            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            DataElement.sequence(
+                [
+                    DataElement.sequence(
+                        [
+                            DataElement.uuid(BT_L2CAP_PROTOCOL_ID),
+                            DataElement.unsigned_integer_16(AVDTP_PSM),
+                        ]
+                    ),
+                    DataElement.sequence(
+                        [
+                            DataElement.uuid(BT_AVDTP_PROTOCOL_ID),
+                            DataElement.unsigned_integer_16(version_int),
+                        ]
+                    ),
+                ]
+            ),
+        ),
+        ServiceAttribute(
+            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            DataElement.sequence(
+                [
+                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                    DataElement.unsigned_integer_16(version_int),
+                ]
+            ),
+        ),
+    ]
+
+
+# -----------------------------------------------------------------------------
+class SbcMediaCodecInformation(
+    namedtuple(
+        'SbcMediaCodecInformation',
+        [
+            'sampling_frequency',
+            'channel_mode',
+            'block_length',
+            'subbands',
+            'allocation_method',
+            'minimum_bitpool_value',
+            'maximum_bitpool_value',
+        ],
+    )
+):
+    '''
+    A2DP spec - 4.3.2 Codec Specific Information Elements
+    '''
+
+    BIT_FIELDS = 'u4u4u4u2u2u8u8'
+    SAMPLING_FREQUENCY_BITS = {16000: 1 << 3, 32000: 1 << 2, 44100: 1 << 1, 48000: 1}
+    CHANNEL_MODE_BITS = {
+        SBC_MONO_CHANNEL_MODE: 1 << 3,
+        SBC_DUAL_CHANNEL_MODE: 1 << 2,
+        SBC_STEREO_CHANNEL_MODE: 1 << 1,
+        SBC_JOINT_STEREO_CHANNEL_MODE: 1,
+    }
+    BLOCK_LENGTH_BITS = {4: 1 << 3, 8: 1 << 2, 12: 1 << 1, 16: 1}
+    SUBBANDS_BITS = {4: 1 << 1, 8: 1}
+    ALLOCATION_METHOD_BITS = {
+        SBC_SNR_ALLOCATION_METHOD: 1 << 1,
+        SBC_LOUDNESS_ALLOCATION_METHOD: 1,
+    }
+
+    @staticmethod
+    def from_bytes(data):
+        return SbcMediaCodecInformation(
+            *bitstruct.unpack(SbcMediaCodecInformation.BIT_FIELDS, data)
+        )
+
+    @classmethod
+    def from_discrete_values(
+        cls,
+        sampling_frequency,
+        channel_mode,
+        block_length,
+        subbands,
+        allocation_method,
+        minimum_bitpool_value,
+        maximum_bitpool_value,
+    ):
+        return SbcMediaCodecInformation(
+            sampling_frequency=cls.SAMPLING_FREQUENCY_BITS[sampling_frequency],
+            channel_mode=cls.CHANNEL_MODE_BITS[channel_mode],
+            block_length=cls.BLOCK_LENGTH_BITS[block_length],
+            subbands=cls.SUBBANDS_BITS[subbands],
+            allocation_method=cls.ALLOCATION_METHOD_BITS[allocation_method],
+            minimum_bitpool_value=minimum_bitpool_value,
+            maximum_bitpool_value=maximum_bitpool_value,
+        )
+
+    @classmethod
+    def from_lists(
+        cls,
+        sampling_frequencies,
+        channel_modes,
+        block_lengths,
+        subbands,
+        allocation_methods,
+        minimum_bitpool_value,
+        maximum_bitpool_value,
+    ):
+        return SbcMediaCodecInformation(
+            sampling_frequency=sum(
+                cls.SAMPLING_FREQUENCY_BITS[x] for x in sampling_frequencies
+            ),
+            channel_mode=sum(cls.CHANNEL_MODE_BITS[x] for x in channel_modes),
+            block_length=sum(cls.BLOCK_LENGTH_BITS[x] for x in block_lengths),
+            subbands=sum(cls.SUBBANDS_BITS[x] for x in subbands),
+            allocation_method=sum(
+                cls.ALLOCATION_METHOD_BITS[x] for x in allocation_methods
+            ),
+            minimum_bitpool_value=minimum_bitpool_value,
+            maximum_bitpool_value=maximum_bitpool_value,
+        )
+
+    def __bytes__(self):
+        return bitstruct.pack(self.BIT_FIELDS, *self)
+
+    def __str__(self):
+        channel_modes = ['MONO', 'DUAL_CHANNEL', 'STEREO', 'JOINT_STEREO']
+        allocation_methods = ['SNR', 'Loudness']
+        return '\n'.join(
+            # pylint: disable=line-too-long
+            [
+                'SbcMediaCodecInformation(',
+                f'  sampling_frequency:    {",".join([str(x) for x in flags_to_list(self.sampling_frequency, SBC_SAMPLING_FREQUENCIES)])}',
+                f'  channel_mode:          {",".join([str(x) for x in flags_to_list(self.channel_mode, channel_modes)])}',
+                f'  block_length:          {",".join([str(x) for x in flags_to_list(self.block_length, SBC_BLOCK_LENGTHS)])}',
+                f'  subbands:              {",".join([str(x) for x in flags_to_list(self.subbands, SBC_SUBBANDS)])}',
+                f'  allocation_method:     {",".join([str(x) for x in flags_to_list(self.allocation_method, allocation_methods)])}',
+                f'  minimum_bitpool_value: {self.minimum_bitpool_value}',
+                f'  maximum_bitpool_value: {self.maximum_bitpool_value}' ')',
+            ]
+        )
+
+
+# -----------------------------------------------------------------------------
+class AacMediaCodecInformation(
+    namedtuple(
+        'AacMediaCodecInformation',
+        ['object_type', 'sampling_frequency', 'channels', 'vbr', 'bitrate'],
+    )
+):
+    '''
+    A2DP spec - 4.5.2 Codec Specific Information Elements
+    '''
+
+    BIT_FIELDS = 'u8u12u2p2u1u23'
+    OBJECT_TYPE_BITS = {
+        MPEG_2_AAC_LC_OBJECT_TYPE: 1 << 7,
+        MPEG_4_AAC_LC_OBJECT_TYPE: 1 << 6,
+        MPEG_4_AAC_LTP_OBJECT_TYPE: 1 << 5,
+        MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 1 << 4,
+    }
+    SAMPLING_FREQUENCY_BITS = {
+        8000: 1 << 11,
+        11025: 1 << 10,
+        12000: 1 << 9,
+        16000: 1 << 8,
+        22050: 1 << 7,
+        24000: 1 << 6,
+        32000: 1 << 5,
+        44100: 1 << 4,
+        48000: 1 << 3,
+        64000: 1 << 2,
+        88200: 1 << 1,
+        96000: 1,
+    }
+    CHANNELS_BITS = {1: 1 << 1, 2: 1}
+
+    @staticmethod
+    def from_bytes(data):
+        return AacMediaCodecInformation(
+            *bitstruct.unpack(AacMediaCodecInformation.BIT_FIELDS, data)
+        )
+
+    @classmethod
+    def from_discrete_values(
+        cls, object_type, sampling_frequency, channels, vbr, bitrate
+    ):
+        return AacMediaCodecInformation(
+            object_type=cls.OBJECT_TYPE_BITS[object_type],
+            sampling_frequency=cls.SAMPLING_FREQUENCY_BITS[sampling_frequency],
+            channels=cls.CHANNELS_BITS[channels],
+            vbr=vbr,
+            bitrate=bitrate,
+        )
+
+    @classmethod
+    def from_lists(cls, object_types, sampling_frequencies, channels, vbr, bitrate):
+        return AacMediaCodecInformation(
+            object_type=sum(cls.OBJECT_TYPE_BITS[x] for x in object_types),
+            sampling_frequency=sum(
+                cls.SAMPLING_FREQUENCY_BITS[x] for x in sampling_frequencies
+            ),
+            channels=sum(cls.CHANNELS_BITS[x] for x in channels),
+            vbr=vbr,
+            bitrate=bitrate,
+        )
+
+    def __bytes__(self):
+        return bitstruct.pack(self.BIT_FIELDS, *self)
+
+    def __str__(self):
+        object_types = [
+            'MPEG_2_AAC_LC',
+            'MPEG_4_AAC_LC',
+            'MPEG_4_AAC_LTP',
+            'MPEG_4_AAC_SCALABLE',
+            '[4]',
+            '[5]',
+            '[6]',
+            '[7]',
+        ]
+        channels = [1, 2]
+        # pylint: disable=line-too-long
+        return '\n'.join(
+            [
+                'AacMediaCodecInformation(',
+                f'  object_type:        {",".join([str(x) for x in flags_to_list(self.object_type, object_types)])}',
+                f'  sampling_frequency: {",".join([str(x) for x in flags_to_list(self.sampling_frequency, MPEG_2_4_AAC_SAMPLING_FREQUENCIES)])}',
+                f'  channels:           {",".join([str(x) for x in flags_to_list(self.channels, channels)])}',
+                f'  vbr:                {self.vbr}',
+                f'  bitrate:            {self.bitrate}' ')',
+            ]
+        )
+
+
+# -----------------------------------------------------------------------------
+class VendorSpecificMediaCodecInformation:
+    '''
+    A2DP spec - 4.7.2 Codec Specific Information Elements
+    '''
+
+    @staticmethod
+    def from_bytes(data):
+        (vendor_id, codec_id) = struct.unpack_from('<IH', data, 0)
+        return VendorSpecificMediaCodecInformation(vendor_id, codec_id, data[6:])
+
+    def __init__(self, vendor_id, codec_id, value):
+        self.vendor_id = vendor_id
+        self.codec_id = codec_id
+        self.value = value
+
+    def __bytes__(self):
+        return struct.pack('<IH', self.vendor_id, self.codec_id, self.value)
+
+    def __str__(self):
+        # pylint: disable=line-too-long
+        return '\n'.join(
+            [
+                'VendorSpecificMediaCodecInformation(',
+                f'  vendor_id: {self.vendor_id:08X} ({name_or_number(COMPANY_IDENTIFIERS, self.vendor_id & 0xFFFF)})',
+                f'  codec_id:  {self.codec_id:04X}',
+                f'  value:     {self.value.hex()}' ')',
+            ]
+        )
+
+
+# -----------------------------------------------------------------------------
+class SbcFrame:
+    def __init__(
+        self, sampling_frequency, block_count, channel_mode, subband_count, payload
+    ):
+        self.sampling_frequency = sampling_frequency
+        self.block_count = block_count
+        self.channel_mode = channel_mode
+        self.subband_count = subband_count
+        self.payload = payload
+
+    @property
+    def sample_count(self):
+        return self.subband_count * self.block_count
+
+    @property
+    def bitrate(self):
+        return 8 * ((len(self.payload) * self.sampling_frequency) // self.sample_count)
+
+    @property
+    def duration(self):
+        return self.sample_count / self.sampling_frequency
+
+    def __str__(self):
+        return (
+            f'SBC(sf={self.sampling_frequency},'
+            f'cm={self.channel_mode},'
+            f'br={self.bitrate},'
+            f'sc={self.sample_count},'
+            f'size={len(self.payload)})'
+        )
+
+
+# -----------------------------------------------------------------------------
+class SbcParser:
+    def __init__(self, read):
+        self.read = read
+
+    @property
+    def frames(self):
+        async def generate_frames():
+            while True:
+                # Read 4 bytes of header
+                header = await self.read(4)
+                if len(header) != 4:
+                    return
+
+                # Check the sync word
+                if header[0] != SBC_SYNC_WORD:
+                    logger.debug('invalid sync word')
+                    return
+
+                # Extract some of the header fields
+                sampling_frequency = SBC_SAMPLING_FREQUENCIES[(header[1] >> 6) & 3]
+                blocks = 4 * (1 + ((header[1] >> 4) & 3))
+                channel_mode = (header[1] >> 2) & 3
+                channels = 1 if channel_mode == SBC_MONO_CHANNEL_MODE else 2
+                subbands = 8 if ((header[1]) & 1) else 4
+                bitpool = header[2]
+
+                # Compute the frame length
+                frame_length = 4 + (4 * subbands * channels) // 8
+                if channel_mode in (SBC_MONO_CHANNEL_MODE, SBC_DUAL_CHANNEL_MODE):
+                    frame_length += (blocks * channels * bitpool) // 8
+                else:
+                    frame_length += (
+                        (1 if channel_mode == SBC_JOINT_STEREO_CHANNEL_MODE else 0)
+                        * subbands
+                        + blocks * bitpool
+                    ) // 8
+
+                # Read the rest of the frame
+                payload = header + await self.read(frame_length - 4)
+
+                # Emit the next frame
+                yield SbcFrame(
+                    sampling_frequency, blocks, channel_mode, subbands, payload
+                )
+
+        return generate_frames()
+
+
+# -----------------------------------------------------------------------------
+class SbcPacketSource:
+    def __init__(self, read, mtu, codec_capabilities):
+        self.read = read
+        self.mtu = mtu
+        self.codec_capabilities = codec_capabilities
+
+    @property
+    def packets(self):
+        async def generate_packets():
+            # pylint: disable=import-outside-toplevel
+            from .avdtp import MediaPacket  # Import here to avoid a circular reference
+
+            sequence_number = 0
+            timestamp = 0
+            frames = []
+            frames_size = 0
+            max_rtp_payload = self.mtu - 12 - 1
+
+            # NOTE: this doesn't support frame fragments
+            sbc_parser = SbcParser(self.read)
+            async for frame in sbc_parser.frames:
+                print(frame)
+
+                if (
+                    frames_size + len(frame.payload) > max_rtp_payload
+                    or len(frames) == 16
+                ):
+                    # Need to flush what has been accumulated so far
+
+                    # Emit a packet
+                    sbc_payload = bytes([len(frames)]) + b''.join(
+                        [frame.payload for frame in frames]
+                    )
+                    packet = MediaPacket(
+                        2, 0, 0, 0, sequence_number, timestamp, 0, [], 96, sbc_payload
+                    )
+                    packet.timestamp_seconds = timestamp / frame.sampling_frequency
+                    yield packet
+
+                    # Prepare for next packets
+                    sequence_number += 1
+                    timestamp += sum((frame.sample_count for frame in frames))
+                    frames = [frame]
+                    frames_size = len(frame.payload)
+                else:
+                    # Accumulate
+                    frames.append(frame)
+                    frames_size += len(frame.payload)
+
+        return generate_packets()

bumble/att.py

@@ -0,0 +1,791 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# ATT - Attribute Protocol
+#
+# See Bluetooth spec @ Vol 3, Part F
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+from colors import color
+from pyee import EventEmitter
+
+from bumble.core import UUID, name_or_number
+from bumble.hci import HCI_Object, key_with_value
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+# fmt: off
+# pylint: disable=line-too-long
+
+ATT_CID = 0x04
+
+ATT_ERROR_RESPONSE              = 0x01
+ATT_EXCHANGE_MTU_REQUEST        = 0x02
+ATT_EXCHANGE_MTU_RESPONSE       = 0x03
+ATT_FIND_INFORMATION_REQUEST    = 0x04
+ATT_FIND_INFORMATION_RESPONSE   = 0x05
+ATT_FIND_BY_TYPE_VALUE_REQUEST  = 0x06
+ATT_FIND_BY_TYPE_VALUE_RESPONSE = 0x07
+ATT_READ_BY_TYPE_REQUEST        = 0x08
+ATT_READ_BY_TYPE_RESPONSE       = 0x09
+ATT_READ_REQUEST                = 0x0A
+ATT_READ_RESPONSE               = 0x0B
+ATT_READ_BLOB_REQUEST           = 0x0C
+ATT_READ_BLOB_RESPONSE          = 0x0D
+ATT_READ_MULTIPLE_REQUEST       = 0x0E
+ATT_READ_MULTIPLE_RESPONSE      = 0x0F
+ATT_READ_BY_GROUP_TYPE_REQUEST  = 0x10
+ATT_READ_BY_GROUP_TYPE_RESPONSE = 0x11
+ATT_WRITE_REQUEST               = 0x12
+ATT_WRITE_RESPONSE              = 0x13
+ATT_WRITE_COMMAND               = 0x52
+ATT_SIGNED_WRITE_COMMAND        = 0xD2
+ATT_PREPARE_WRITE_REQUEST       = 0x16
+ATT_PREPARE_WRITE_RESPONSE      = 0x17
+ATT_EXECUTE_WRITE_REQUEST       = 0x18
+ATT_EXECUTE_WRITE_RESPONSE      = 0x19
+ATT_HANDLE_VALUE_NOTIFICATION   = 0x1B
+ATT_HANDLE_VALUE_INDICATION     = 0x1D
+ATT_HANDLE_VALUE_CONFIRMATION   = 0x1E
+
+ATT_PDU_NAMES = {
+    ATT_ERROR_RESPONSE:              'ATT_ERROR_RESPONSE',
+    ATT_EXCHANGE_MTU_REQUEST:        'ATT_EXCHANGE_MTU_REQUEST',
+    ATT_EXCHANGE_MTU_RESPONSE:       'ATT_EXCHANGE_MTU_RESPONSE',
+    ATT_FIND_INFORMATION_REQUEST:    'ATT_FIND_INFORMATION_REQUEST',
+    ATT_FIND_INFORMATION_RESPONSE:   'ATT_FIND_INFORMATION_RESPONSE',
+    ATT_FIND_BY_TYPE_VALUE_REQUEST:  'ATT_FIND_BY_TYPE_VALUE_REQUEST',
+    ATT_FIND_BY_TYPE_VALUE_RESPONSE: 'ATT_FIND_BY_TYPE_VALUE_RESPONSE',
+    ATT_READ_BY_TYPE_REQUEST:        'ATT_READ_BY_TYPE_REQUEST',
+    ATT_READ_BY_TYPE_RESPONSE:       'ATT_READ_BY_TYPE_RESPONSE',
+    ATT_READ_REQUEST:                'ATT_READ_REQUEST',
+    ATT_READ_RESPONSE:               'ATT_READ_RESPONSE',
+    ATT_READ_BLOB_REQUEST:           'ATT_READ_BLOB_REQUEST',
+    ATT_READ_BLOB_RESPONSE:          'ATT_READ_BLOB_RESPONSE',
+    ATT_READ_MULTIPLE_REQUEST:       'ATT_READ_MULTIPLE_REQUEST',
+    ATT_READ_MULTIPLE_RESPONSE:      'ATT_READ_MULTIPLE_RESPONSE',
+    ATT_READ_BY_GROUP_TYPE_REQUEST:  'ATT_READ_BY_GROUP_TYPE_REQUEST',
+    ATT_READ_BY_GROUP_TYPE_RESPONSE: 'ATT_READ_BY_GROUP_TYPE_RESPONSE',
+    ATT_WRITE_REQUEST:               'ATT_WRITE_REQUEST',
+    ATT_WRITE_RESPONSE:              'ATT_WRITE_RESPONSE',
+    ATT_WRITE_COMMAND:               'ATT_WRITE_COMMAND',
+    ATT_SIGNED_WRITE_COMMAND:        'ATT_SIGNED_WRITE_COMMAND',
+    ATT_PREPARE_WRITE_REQUEST:       'ATT_PREPARE_WRITE_REQUEST',
+    ATT_PREPARE_WRITE_RESPONSE:      'ATT_PREPARE_WRITE_RESPONSE',
+    ATT_EXECUTE_WRITE_REQUEST:       'ATT_EXECUTE_WRITE_REQUEST',
+    ATT_EXECUTE_WRITE_RESPONSE:      'ATT_EXECUTE_WRITE_RESPONSE',
+    ATT_HANDLE_VALUE_NOTIFICATION:   'ATT_HANDLE_VALUE_NOTIFICATION',
+    ATT_HANDLE_VALUE_INDICATION:     'ATT_HANDLE_VALUE_INDICATION',
+    ATT_HANDLE_VALUE_CONFIRMATION:   'ATT_HANDLE_VALUE_CONFIRMATION'
+}
+
+ATT_REQUESTS = [
+    ATT_EXCHANGE_MTU_REQUEST,
+    ATT_FIND_INFORMATION_REQUEST,
+    ATT_FIND_BY_TYPE_VALUE_REQUEST,
+    ATT_READ_BY_TYPE_REQUEST,
+    ATT_READ_REQUEST,
+    ATT_READ_BLOB_REQUEST,
+    ATT_READ_MULTIPLE_REQUEST,
+    ATT_READ_BY_GROUP_TYPE_REQUEST,
+    ATT_WRITE_REQUEST,
+    ATT_PREPARE_WRITE_REQUEST,
+    ATT_EXECUTE_WRITE_REQUEST
+]
+
+ATT_RESPONSES = [
+    ATT_ERROR_RESPONSE,
+    ATT_EXCHANGE_MTU_RESPONSE,
+    ATT_FIND_INFORMATION_RESPONSE,
+    ATT_FIND_BY_TYPE_VALUE_RESPONSE,
+    ATT_READ_BY_TYPE_RESPONSE,
+    ATT_READ_RESPONSE,
+    ATT_READ_BLOB_RESPONSE,
+    ATT_READ_MULTIPLE_RESPONSE,
+    ATT_READ_BY_GROUP_TYPE_RESPONSE,
+    ATT_WRITE_RESPONSE,
+    ATT_PREPARE_WRITE_RESPONSE,
+    ATT_EXECUTE_WRITE_RESPONSE
+]
+
+ATT_INVALID_HANDLE_ERROR                   = 0x01
+ATT_READ_NOT_PERMITTED_ERROR               = 0x02
+ATT_WRITE_NOT_PERMITTED_ERROR              = 0x03
+ATT_INVALID_PDU_ERROR                      = 0x04
+ATT_INSUFFICIENT_AUTHENTICATION_ERROR      = 0x05
+ATT_REQUEST_NOT_SUPPORTED_ERROR            = 0x06
+ATT_INVALID_OFFSET_ERROR                   = 0x07
+ATT_INSUFFICIENT_AUTHORIZATION_ERROR       = 0x08
+ATT_PREPARE_QUEUE_FULL_ERROR               = 0x09
+ATT_ATTRIBUTE_NOT_FOUND_ERROR              = 0x0A
+ATT_ATTRIBUTE_NOT_LONG_ERROR               = 0x0B
+ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR = 0x0C
+ATT_INVALID_ATTRIBUTE_LENGTH_ERROR         = 0x0D
+ATT_UNLIKELY_ERROR_ERROR                   = 0x0E
+ATT_INSUFFICIENT_ENCRYPTION_ERROR          = 0x0F
+ATT_UNSUPPORTED_GROUP_TYPE_ERROR           = 0x10
+ATT_INSUFFICIENT_RESOURCES_ERROR           = 0x11
+
+ATT_ERROR_NAMES = {
+    ATT_INVALID_HANDLE_ERROR:                   'ATT_INVALID_HANDLE_ERROR',
+    ATT_READ_NOT_PERMITTED_ERROR:               'ATT_READ_NOT_PERMITTED_ERROR',
+    ATT_WRITE_NOT_PERMITTED_ERROR:              'ATT_WRITE_NOT_PERMITTED_ERROR',
+    ATT_INVALID_PDU_ERROR:                      'ATT_INVALID_PDU_ERROR',
+    ATT_INSUFFICIENT_AUTHENTICATION_ERROR:      'ATT_INSUFFICIENT_AUTHENTICATION_ERROR',
+    ATT_REQUEST_NOT_SUPPORTED_ERROR:            'ATT_REQUEST_NOT_SUPPORTED_ERROR',
+    ATT_INVALID_OFFSET_ERROR:                   'ATT_INVALID_OFFSET_ERROR',
+    ATT_INSUFFICIENT_AUTHORIZATION_ERROR:       'ATT_INSUFFICIENT_AUTHORIZATION_ERROR',
+    ATT_PREPARE_QUEUE_FULL_ERROR:               'ATT_PREPARE_QUEUE_FULL_ERROR',
+    ATT_ATTRIBUTE_NOT_FOUND_ERROR:              'ATT_ATTRIBUTE_NOT_FOUND_ERROR',
+    ATT_ATTRIBUTE_NOT_LONG_ERROR:               'ATT_ATTRIBUTE_NOT_LONG_ERROR',
+    ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR: 'ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR',
+    ATT_INVALID_ATTRIBUTE_LENGTH_ERROR:         'ATT_INVALID_ATTRIBUTE_LENGTH_ERROR',
+    ATT_UNLIKELY_ERROR_ERROR:                   'ATT_UNLIKELY_ERROR_ERROR',
+    ATT_INSUFFICIENT_ENCRYPTION_ERROR:          'ATT_INSUFFICIENT_ENCRYPTION_ERROR',
+    ATT_UNSUPPORTED_GROUP_TYPE_ERROR:           'ATT_UNSUPPORTED_GROUP_TYPE_ERROR',
+    ATT_INSUFFICIENT_RESOURCES_ERROR:           'ATT_INSUFFICIENT_RESOURCES_ERROR'
+}
+
+ATT_DEFAULT_MTU = 23
+
+HANDLE_FIELD_SPEC    = {'size': 2, 'mapper': lambda x: f'0x{x:04X}'}
+# pylint: disable-next=unnecessary-lambda-assignment,unnecessary-lambda
+UUID_2_16_FIELD_SPEC = lambda x, y: UUID.parse_uuid(x, y)
+# pylint: disable-next=unnecessary-lambda-assignment,unnecessary-lambda
+UUID_2_FIELD_SPEC    = lambda x, y: UUID.parse_uuid_2(x, y)  # noqa: E731
+
+# fmt: on
+# pylint: enable=line-too-long
+# pylint: disable=invalid-name
+
+# -----------------------------------------------------------------------------
+# Exceptions
+# -----------------------------------------------------------------------------
+class ATT_Error(Exception):
+    def __init__(self, error_code, att_handle=0x0000):
+        self.error_code = error_code
+        self.att_handle = att_handle
+
+    def __str__(self):
+        return f'ATT_Error({ATT_PDU.error_name(self.error_code)})'
+
+
+# -----------------------------------------------------------------------------
+# Attribute Protocol
+# -----------------------------------------------------------------------------
+class ATT_PDU:
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.3 ATTRIBUTE PDU
+    '''
+
+    pdu_classes = {}
+    op_code = 0
+    name = None
+
+    @staticmethod
+    def from_bytes(pdu):
+        op_code = pdu[0]
+
+        cls = ATT_PDU.pdu_classes.get(op_code)
+        if cls is None:
+            instance = ATT_PDU(pdu)
+            instance.name = ATT_PDU.pdu_name(op_code)
+            instance.op_code = op_code
+            return instance
+        self = cls.__new__(cls)
+        ATT_PDU.__init__(self, pdu)
+        if hasattr(self, 'fields'):
+            self.init_from_bytes(pdu, 1)
+        return self
+
+    @staticmethod
+    def pdu_name(op_code):
+        return name_or_number(ATT_PDU_NAMES, op_code, 2)
+
+    @staticmethod
+    def error_name(error_code):
+        return name_or_number(ATT_ERROR_NAMES, error_code, 2)
+
+    @staticmethod
+    def subclass(fields):
+        def inner(cls):
+            cls.name = cls.__name__.upper()
+            cls.op_code = key_with_value(ATT_PDU_NAMES, cls.name)
+            if cls.op_code is None:
+                raise KeyError(f'PDU name {cls.name} not found in ATT_PDU_NAMES')
+            cls.fields = fields
+
+            # Register a factory for this class
+            ATT_PDU.pdu_classes[cls.op_code] = cls
+
+            return cls
+
+        return inner
+
+    def __init__(self, pdu=None, **kwargs):
+        if hasattr(self, 'fields') and kwargs:
+            HCI_Object.init_from_fields(self, self.fields, kwargs)
+        if pdu is None:
+            pdu = bytes([self.op_code]) + HCI_Object.dict_to_bytes(kwargs, self.fields)
+        self.pdu = pdu
+
+    def init_from_bytes(self, pdu, offset):
+        return HCI_Object.init_from_bytes(self, pdu, offset, self.fields)
+
+    def to_bytes(self):
+        return self.pdu
+
+    @property
+    def is_command(self):
+        return ((self.op_code >> 6) & 1) == 1
+
+    @property
+    def has_authentication_signature(self):
+        return ((self.op_code >> 7) & 1) == 1
+
+    def __bytes__(self):
+        return self.to_bytes()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        if fields := getattr(self, 'fields', None):
+            result += ':\n' + HCI_Object.format_fields(self.__dict__, fields, '  ')
+        else:
+            if len(self.pdu) > 1:
+                result += f': {self.pdu.hex()}'
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('request_opcode_in_error', {'size': 1, 'mapper': ATT_PDU.pdu_name}),
+        ('attribute_handle_in_error', HANDLE_FIELD_SPEC),
+        ('error_code', {'size': 1, 'mapper': ATT_PDU.error_name}),
+    ]
+)
+class ATT_Error_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.1.1 Error Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('client_rx_mtu', 2)])
+class ATT_Exchange_MTU_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.2.1 Exchange MTU Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('server_rx_mtu', 2)])
+class ATT_Exchange_MTU_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.2.2 Exchange MTU Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [('starting_handle', HANDLE_FIELD_SPEC), ('ending_handle', HANDLE_FIELD_SPEC)]
+)
+class ATT_Find_Information_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.1 Find Information Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('format', 1), ('information_data', '*')])
+class ATT_Find_Information_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.2 Find Information Response
+    '''
+
+    def parse_information_data(self):
+        self.information = []
+        offset = 0
+        uuid_size = 2 if self.format == 1 else 16
+        while offset + uuid_size <= len(self.information_data):
+            handle = struct.unpack_from('<H', self.information_data, offset)[0]
+            uuid = self.information_data[2 + offset : 2 + offset + uuid_size]
+            self.information.append((handle, uuid))
+            offset += 2 + uuid_size
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_information_data()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_information_data()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(
+            self.__dict__,
+            [
+                ('format', 1),
+                (
+                    'information',
+                    {
+                        'mapper': lambda x: ', '.join(
+                            [f'0x{handle:04X}:{uuid.hex()}' for handle, uuid in x]
+                        )
+                    },
+                ),
+            ],
+            '  ',
+        )
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('starting_handle', HANDLE_FIELD_SPEC),
+        ('ending_handle', HANDLE_FIELD_SPEC),
+        ('attribute_type', UUID_2_FIELD_SPEC),
+        ('attribute_value', '*'),
+    ]
+)
+class ATT_Find_By_Type_Value_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.3 Find By Type Value Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('handles_information_list', '*')])
+class ATT_Find_By_Type_Value_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.4 Find By Type Value Response
+    '''
+
+    def parse_handles_information_list(self):
+        self.handles_information = []
+        offset = 0
+        while offset + 4 <= len(self.handles_information_list):
+            found_attribute_handle, group_end_handle = struct.unpack_from(
+                '<HH', self.handles_information_list, offset
+            )
+            self.handles_information.append((found_attribute_handle, group_end_handle))
+            offset += 4
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_handles_information_list()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_handles_information_list()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(
+            self.__dict__,
+            [
+                (
+                    'handles_information',
+                    {
+                        'mapper': lambda x: ', '.join(
+                            [
+                                f'0x{handle1:04X}-0x{handle2:04X}'
+                                for handle1, handle2 in x
+                            ]
+                        )
+                    },
+                )
+            ],
+            '  ',
+        )
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('starting_handle', HANDLE_FIELD_SPEC),
+        ('ending_handle', HANDLE_FIELD_SPEC),
+        ('attribute_type', UUID_2_16_FIELD_SPEC),
+    ]
+)
+class ATT_Read_By_Type_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.1 Read By Type Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('length', 1), ('attribute_data_list', '*')])
+class ATT_Read_By_Type_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.2 Read By Type Response
+    '''
+
+    def parse_attribute_data_list(self):
+        self.attributes = []
+        offset = 0
+        while self.length != 0 and offset + self.length <= len(
+            self.attribute_data_list
+        ):
+            (attribute_handle,) = struct.unpack_from(
+                '<H', self.attribute_data_list, offset
+            )
+            attribute_value = self.attribute_data_list[
+                offset + 2 : offset + self.length
+            ]
+            self.attributes.append((attribute_handle, attribute_value))
+            offset += self.length
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_attribute_data_list()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_attribute_data_list()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(
+            self.__dict__,
+            [
+                ('length', 1),
+                (
+                    'attributes',
+                    {
+                        'mapper': lambda x: ', '.join(
+                            [f'0x{handle:04X}:{value.hex()}' for handle, value in x]
+                        )
+                    },
+                ),
+            ],
+            '  ',
+        )
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_handle', HANDLE_FIELD_SPEC)])
+class ATT_Read_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.3 Read Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_value', '*')])
+class ATT_Read_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.4 Read Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_handle', HANDLE_FIELD_SPEC), ('value_offset', 2)])
+class ATT_Read_Blob_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.5 Read Blob Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('part_attribute_value', '*')])
+class ATT_Read_Blob_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.6 Read Blob Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('set_of_handles', '*')])
+class ATT_Read_Multiple_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.7 Read Multiple Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('set_of_values', '*')])
+class ATT_Read_Multiple_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.8 Read Multiple Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('starting_handle', HANDLE_FIELD_SPEC),
+        ('ending_handle', HANDLE_FIELD_SPEC),
+        ('attribute_group_type', UUID_2_16_FIELD_SPEC),
+    ]
+)
+class ATT_Read_By_Group_Type_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.9 Read by Group Type Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('length', 1), ('attribute_data_list', '*')])
+class ATT_Read_By_Group_Type_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.10 Read by Group Type Response
+    '''
+
+    def parse_attribute_data_list(self):
+        self.attributes = []
+        offset = 0
+        while self.length != 0 and offset + self.length <= len(
+            self.attribute_data_list
+        ):
+            attribute_handle, end_group_handle = struct.unpack_from(
+                '<HH', self.attribute_data_list, offset
+            )
+            attribute_value = self.attribute_data_list[
+                offset + 4 : offset + self.length
+            ]
+            self.attributes.append(
+                (attribute_handle, end_group_handle, attribute_value)
+            )
+            offset += self.length
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_attribute_data_list()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_attribute_data_list()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(
+            self.__dict__,
+            [
+                ('length', 1),
+                (
+                    'attributes',
+                    {
+                        'mapper': lambda x: ', '.join(
+                            [
+                                f'0x{handle:04X}-0x{end:04X}:{value.hex()}'
+                                for handle, end, value in x
+                            ]
+                        )
+                    },
+                ),
+            ],
+            '  ',
+        )
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_handle', HANDLE_FIELD_SPEC), ('attribute_value', '*')])
+class ATT_Write_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.1 Write Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Write_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.2 Write Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_handle', HANDLE_FIELD_SPEC), ('attribute_value', '*')])
+class ATT_Write_Command(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.3 Write Command
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('attribute_handle', HANDLE_FIELD_SPEC),
+        ('attribute_value', '*')
+        # ('authentication_signature', 'TODO')
+    ]
+)
+class ATT_Signed_Write_Command(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.4 Signed Write Command
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('attribute_handle', HANDLE_FIELD_SPEC),
+        ('value_offset', 2),
+        ('part_attribute_value', '*'),
+    ]
+)
+class ATT_Prepare_Write_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.1 Prepare Write Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass(
+    [
+        ('attribute_handle', HANDLE_FIELD_SPEC),
+        ('value_offset', 2),
+        ('part_attribute_value', '*'),
+    ]
+)
+class ATT_Prepare_Write_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.2 Prepare Write Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Execute_Write_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.3 Execute Write Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Execute_Write_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.4 Execute Write Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_handle', HANDLE_FIELD_SPEC), ('attribute_value', '*')])
+class ATT_Handle_Value_Notification(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.7.1 Handle Value Notification
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([('attribute_handle', HANDLE_FIELD_SPEC), ('attribute_value', '*')])
+class ATT_Handle_Value_Indication(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.7.2 Handle Value Indication
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Handle_Value_Confirmation(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.7.3 Handle Value Confirmation
+    '''
+
+
+# -----------------------------------------------------------------------------
+class Attribute(EventEmitter):
+    # Permission flags
+    READABLE = 0x01
+    WRITEABLE = 0x02
+    READ_REQUIRES_ENCRYPTION = 0x04
+    WRITE_REQUIRES_ENCRYPTION = 0x08
+    READ_REQUIRES_AUTHENTICATION = 0x10
+    WRITE_REQUIRES_AUTHENTICATION = 0x20
+    READ_REQUIRES_AUTHORIZATION = 0x40
+    WRITE_REQUIRES_AUTHORIZATION = 0x80
+
+    def __init__(self, attribute_type, permissions, value=b''):
+        EventEmitter.__init__(self)
+        self.handle = 0
+        self.end_group_handle = 0
+        self.permissions = permissions
+
+        # Convert the type to a UUID object if it isn't already
+        if isinstance(attribute_type, str):
+            self.type = UUID(attribute_type)
+        elif isinstance(attribute_type, bytes):
+            self.type = UUID.from_bytes(attribute_type)
+        else:
+            self.type = attribute_type
+
+        # Convert the value to a byte array
+        if isinstance(value, str):
+            self.value = bytes(value, 'utf-8')
+        else:
+            self.value = value
+
+    def encode_value(self, value):
+        return value
+
+    def decode_value(self, value_bytes):
+        return value_bytes
+
+    def read_value(self, connection):
+        if read := getattr(self.value, 'read', None):
+            try:
+                value = read(connection)  # pylint: disable=not-callable
+            except ATT_Error as error:
+                raise ATT_Error(
+                    error_code=error.error_code, att_handle=self.handle
+                ) from error
+        else:
+            value = self.value
+
+        return self.encode_value(value)
+
+    def write_value(self, connection, value_bytes):
+        value = self.decode_value(value_bytes)
+
+        if write := getattr(self.value, 'write', None):
+            try:
+                write(connection, value)  # pylint: disable=not-callable
+            except ATT_Error as error:
+                raise ATT_Error(
+                    error_code=error.error_code, att_handle=self.handle
+                ) from error
+        else:
+            self.value = value
+
+        self.emit('write', connection, value)
+
+    def __repr__(self):
+        if isinstance(self.value, bytes):
+            value_str = self.value.hex()
+        else:
+            value_str = str(self.value)
+        if value_str:
+            value_string = f', value={self.value.hex()}'
+        else:
+            value_string = ''
+        return (
+            f'Attribute(handle=0x{self.handle:04X}, '
+            f'type={self.type}, '
+            f'permissions={self.permissions}{value_string})'
+        )

bumble/bridge.py

@@ -0,0 +1,82 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+
+from .hci import HCI_Packet
+from .helpers import PacketTracer
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+class HCI_Bridge:
+    class Forwarder:
+        def __init__(self, hci_sink, sender_hci_sink, packet_filter, trace):
+            self.hci_sink = hci_sink
+            self.sender_hci_sink = sender_hci_sink
+            self.packet_filter = packet_filter
+            self.trace = trace
+
+        def on_packet(self, packet):
+            # Convert the packet bytes to an object
+            hci_packet = HCI_Packet.from_bytes(packet)
+
+            # Filter the packet
+            if self.packet_filter is not None:
+                filtered = self.packet_filter(hci_packet)
+                if filtered is not None:
+                    packet, respond_to_sender = filtered
+                    hci_packet = HCI_Packet.from_bytes(packet)
+                    if respond_to_sender:
+                        self.sender_hci_sink.on_packet(packet)
+                        return
+
+            # Analyze the packet
+            self.trace(hci_packet)
+
+            # Bridge the packet
+            self.hci_sink.on_packet(packet)
+
+    def __init__(
+        self,
+        hci_host_source,
+        hci_host_sink,
+        hci_controller_source,
+        hci_controller_sink,
+        host_to_controller_filter=None,
+        controller_to_host_filter=None,
+    ):
+        tracer = PacketTracer(emit_message=logger.info)
+        host_to_controller_forwarder = HCI_Bridge.Forwarder(
+            hci_controller_sink,
+            hci_host_sink,
+            host_to_controller_filter,
+            lambda packet: tracer.trace(packet, 0),
+        )
+        hci_host_source.set_packet_sink(host_to_controller_forwarder)
+
+        controller_to_host_forwarder = HCI_Bridge.Forwarder(
+            hci_host_sink,
+            hci_controller_sink,
+            controller_to_host_filter,
+            lambda packet: tracer.trace(packet, 1),
+        )
+        hci_controller_source.set_packet_sink(controller_to_host_forwarder)

bumble/core.py

@@ -0,0 +1,961 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+
+from .company_ids import COMPANY_IDENTIFIERS
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+# fmt: off
+
+BT_CENTRAL_ROLE    = 0
+BT_PERIPHERAL_ROLE = 1
+
+BT_BR_EDR_TRANSPORT = 0
+BT_LE_TRANSPORT     = 1
+
+
+# fmt: on
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+def bit_flags_to_strings(bits, bit_flag_names):
+    names = []
+    index = 0
+    while bits != 0:
+        if bits & 1:
+            name = bit_flag_names[index] if index < len(bit_flag_names) else f'#{index}'
+            names.append(name)
+        bits >>= 1
+        index += 1
+
+    return names
+
+
+def name_or_number(dictionary, number, width=2):
+    name = dictionary.get(number)
+    if name is not None:
+        return name
+    return f'[0x{number:0{width}X}]'
+
+
+def padded_bytes(buffer, size):
+    padding_size = max(size - len(buffer), 0)
+    return buffer + bytes(padding_size)
+
+
+def get_dict_key_by_value(dictionary, value):
+    for key, val in dictionary.items():
+        if val == value:
+            return key
+    return None
+
+
+# -----------------------------------------------------------------------------
+# Exceptions
+# -----------------------------------------------------------------------------
+class BaseError(Exception):
+    """Base class for errors with an error code, error name and namespace"""
+
+    def __init__(self, error_code, error_namespace='', error_name='', details=''):
+        super().__init__()
+        self.error_code = error_code
+        self.error_namespace = error_namespace
+        self.error_name = error_name
+        self.details = details
+
+    def __str__(self):
+        if self.error_namespace:
+            namespace = f'{self.error_namespace}/'
+        else:
+            namespace = ''
+        if self.error_name:
+            name = f'{self.error_name} [0x{self.error_code:X}]'
+        else:
+            name = f'0x{self.error_code:X}'
+
+        return f'{type(self).__name__}({namespace}{name})'
+
+
+class ProtocolError(BaseError):
+    """Protocol Error"""
+
+
+class TimeoutError(Exception):  # pylint: disable=redefined-builtin
+    """Timeout Error"""
+
+
+class CommandTimeoutError(Exception):
+    """Command Timeout Error"""
+
+
+class InvalidStateError(Exception):
+    """Invalid State Error"""
+
+
+class ConnectionError(BaseError):  # pylint: disable=redefined-builtin
+    """Connection Error"""
+
+    FAILURE = 0x01
+    CONNECTION_REFUSED = 0x02
+
+    def __init__(
+        self,
+        error_code,
+        transport,
+        peer_address,
+        error_namespace='',
+        error_name='',
+        details='',
+    ):
+        super().__init__(error_code, error_namespace, error_name, details)
+        self.transport = transport
+        self.peer_address = peer_address
+
+
+# -----------------------------------------------------------------------------
+# UUID
+#
+# NOTE: the internal byte representation is in little-endian byte order
+#
+# Base UUID: 00000000-0000-1000-8000- 00805F9B34FB
+# -----------------------------------------------------------------------------
+class UUID:
+    '''
+    See Bluetooth spec Vol 3, Part B - 2.5.1 UUID
+    '''
+
+    BASE_UUID = bytes.fromhex('00001000800000805F9B34FB')
+    UUIDS = []  # Registry of all instances created
+
+    def __init__(self, uuid_str_or_int, name=None):
+        if isinstance(uuid_str_or_int, int):
+            self.uuid_bytes = struct.pack('<H', uuid_str_or_int)
+        else:
+            if len(uuid_str_or_int) == 36:
+                if (
+                    uuid_str_or_int[8] != '-'
+                    or uuid_str_or_int[13] != '-'
+                    or uuid_str_or_int[18] != '-'
+                    or uuid_str_or_int[23] != '-'
+                ):
+                    raise ValueError('invalid UUID format')
+                uuid_str = uuid_str_or_int.replace('-', '')
+            else:
+                uuid_str = uuid_str_or_int
+            if len(uuid_str) != 32 and len(uuid_str) != 8 and len(uuid_str) != 4:
+                raise ValueError(f"invalid UUID format: {uuid_str}")
+            self.uuid_bytes = bytes(reversed(bytes.fromhex(uuid_str)))
+        self.name = name
+
+    def register(self):
+        # Register this object in the class registry, and update the entry's name if
+        # it wasn't set already
+        for uuid in self.UUIDS:
+            if self == uuid:
+                if uuid.name is None:
+                    uuid.name = self.name
+                return uuid
+
+        self.UUIDS.append(self)
+        return self
+
+    @classmethod
+    def from_bytes(cls, uuid_bytes, name=None):
+        if len(uuid_bytes) in (2, 4, 16):
+            self = cls.__new__(cls)
+            self.uuid_bytes = uuid_bytes
+            self.name = name
+
+            return self.register()
+
+        raise ValueError('only 2, 4 and 16 bytes are allowed')
+
+    @classmethod
+    def from_16_bits(cls, uuid_16, name=None):
+        return cls.from_bytes(struct.pack('<H', uuid_16), name)
+
+    @classmethod
+    def from_32_bits(cls, uuid_32, name=None):
+        return cls.from_bytes(struct.pack('<I', uuid_32), name)
+
+    @classmethod
+    def parse_uuid(cls, uuid_as_bytes, offset):
+        return len(uuid_as_bytes), cls.from_bytes(uuid_as_bytes[offset:])
+
+    @classmethod
+    def parse_uuid_2(cls, uuid_as_bytes, offset):
+        return offset + 2, cls.from_bytes(uuid_as_bytes[offset : offset + 2])
+
+    def to_bytes(self, force_128=False):
+        if len(self.uuid_bytes) == 16 or not force_128:
+            return self.uuid_bytes
+
+        if len(self.uuid_bytes) == 4:
+            return self.uuid_bytes + UUID.BASE_UUID
+
+        return self.uuid_bytes + bytes([0, 0]) + UUID.BASE_UUID
+
+    def to_pdu_bytes(self):
+        '''
+        Convert to bytes for use in an ATT PDU.
+        According to Vol 3, Part F - 3.2.1 Attribute Type:
+        "All 32-bit Attribute UUIDs shall be converted to 128-bit UUIDs when the
+         Attribute UUID is contained in an ATT PDU."
+        '''
+        return self.to_bytes(force_128=(len(self.uuid_bytes) == 4))
+
+    def to_hex_str(self):
+        if len(self.uuid_bytes) == 2 or len(self.uuid_bytes) == 4:
+            return bytes(reversed(self.uuid_bytes)).hex().upper()
+
+        return ''.join(
+            [
+                bytes(reversed(self.uuid_bytes[12:16])).hex(),
+                bytes(reversed(self.uuid_bytes[10:12])).hex(),
+                bytes(reversed(self.uuid_bytes[8:10])).hex(),
+                bytes(reversed(self.uuid_bytes[6:8])).hex(),
+                bytes(reversed(self.uuid_bytes[0:6])).hex(),
+            ]
+        ).upper()
+
+    def __bytes__(self):
+        return self.to_bytes()
+
+    def __eq__(self, other):
+        if isinstance(other, UUID):
+            return self.to_bytes(force_128=True) == other.to_bytes(force_128=True)
+
+        if isinstance(other, str):
+            return UUID(other) == self
+
+        return False
+
+    def __hash__(self):
+        return hash(self.uuid_bytes)
+
+    def __str__(self):
+        if len(self.uuid_bytes) == 2:
+            uuid = struct.unpack('<H', self.uuid_bytes)[0]
+            result = f'UUID-16:{uuid:04X}'
+        elif len(self.uuid_bytes) == 4:
+            uuid = struct.unpack('<I', self.uuid_bytes)[0]
+            result = f'UUID-32:{uuid:08X}'
+        else:
+            result = '-'.join(
+                [
+                    bytes(reversed(self.uuid_bytes[12:16])).hex(),
+                    bytes(reversed(self.uuid_bytes[10:12])).hex(),
+                    bytes(reversed(self.uuid_bytes[8:10])).hex(),
+                    bytes(reversed(self.uuid_bytes[6:8])).hex(),
+                    bytes(reversed(self.uuid_bytes[0:6])).hex(),
+                ]
+            ).upper()
+
+        if self.name is not None:
+            return result + f' ({self.name})'
+
+        return result
+
+    def __repr__(self):
+        return str(self)
+
+
+# -----------------------------------------------------------------------------
+# Common UUID constants
+# -----------------------------------------------------------------------------
+# fmt: off
+# pylint: disable=line-too-long
+
+# Protocol Identifiers
+BT_SDP_PROTOCOL_ID                      = UUID.from_16_bits(0x0001, 'SDP')
+BT_UDP_PROTOCOL_ID                      = UUID.from_16_bits(0x0002, 'UDP')
+BT_RFCOMM_PROTOCOL_ID                   = UUID.from_16_bits(0x0003, 'RFCOMM')
+BT_TCP_PROTOCOL_ID                      = UUID.from_16_bits(0x0004, 'TCP')
+BT_TCS_BIN_PROTOCOL_ID                  = UUID.from_16_bits(0x0005, 'TCP-BIN')
+BT_TCS_AT_PROTOCOL_ID                   = UUID.from_16_bits(0x0006, 'TCS-AT')
+BT_ATT_PROTOCOL_ID                      = UUID.from_16_bits(0x0007, 'ATT')
+BT_OBEX_PROTOCOL_ID                     = UUID.from_16_bits(0x0008, 'OBEX')
+BT_IP_PROTOCOL_ID                       = UUID.from_16_bits(0x0009, 'IP')
+BT_FTP_PROTOCOL_ID                      = UUID.from_16_bits(0x000A, 'FTP')
+BT_HTTP_PROTOCOL_ID                     = UUID.from_16_bits(0x000C, 'HTTP')
+BT_WSP_PROTOCOL_ID                      = UUID.from_16_bits(0x000E, 'WSP')
+BT_BNEP_PROTOCOL_ID                     = UUID.from_16_bits(0x000F, 'BNEP')
+BT_UPNP_PROTOCOL_ID                     = UUID.from_16_bits(0x0010, 'UPNP')
+BT_HIDP_PROTOCOL_ID                     = UUID.from_16_bits(0x0011, 'HIDP')
+BT_HARDCOPY_CONTROL_CHANNEL_PROTOCOL_ID = UUID.from_16_bits(0x0012, 'HardcopyControlChannel')
+BT_HARDCOPY_DATA_CHANNEL_PROTOCOL_ID    = UUID.from_16_bits(0x0014, 'HardcopyDataChannel')
+BT_HARDCOPY_NOTIFICATION_PROTOCOL_ID    = UUID.from_16_bits(0x0016, 'HardcopyNotification')
+BT_AVTCP_PROTOCOL_ID                    = UUID.from_16_bits(0x0017, 'AVCTP')
+BT_AVDTP_PROTOCOL_ID                    = UUID.from_16_bits(0x0019, 'AVDTP')
+BT_CMTP_PROTOCOL_ID                     = UUID.from_16_bits(0x001B, 'CMTP')
+BT_MCAP_CONTROL_CHANNEL_PROTOCOL_ID     = UUID.from_16_bits(0x001E, 'MCAPControlChannel')
+BT_MCAP_DATA_CHANNEL_PROTOCOL_ID        = UUID.from_16_bits(0x001F, 'MCAPDataChannel')
+BT_L2CAP_PROTOCOL_ID                    = UUID.from_16_bits(0x0100, 'L2CAP')
+
+# Service Classes and Profiles
+BT_SERVICE_DISCOVERY_SERVER_SERVICE_CLASS_ID_SERVICE = UUID.from_16_bits(0x1000, 'ServiceDiscoveryServerServiceClassID')
+BT_BROWSE_GROUP_DESCRIPTOR_SERVICE_CLASS_ID_SERVICE  = UUID.from_16_bits(0x1001, 'BrowseGroupDescriptorServiceClassID')
+BT_SERIAL_PORT_SERVICE                               = UUID.from_16_bits(0x1101, 'SerialPort')
+BT_LAN_ACCESS_USING_PPP_SERVICE                      = UUID.from_16_bits(0x1102, 'LANAccessUsingPPP')
+BT_DIALUP_NETWORKING_SERVICE                         = UUID.from_16_bits(0x1103, 'DialupNetworking')
+BT_IR_MCSYNC_SERVICE                                 = UUID.from_16_bits(0x1104, 'IrMCSync')
+BT_OBEX_OBJECT_PUSH_SERVICE                          = UUID.from_16_bits(0x1105, 'OBEXObjectPush')
+BT_OBEX_FILE_TRANSFER_SERVICE                        = UUID.from_16_bits(0x1106, 'OBEXFileTransfer')
+BT_IR_MCSYNC_COMMAND_SERVICE                         = UUID.from_16_bits(0x1107, 'IrMCSyncCommand')
+BT_HEADSET_SERVICE                                   = UUID.from_16_bits(0x1108, 'Headset')
+BT_CORDLESS_TELEPHONY_SERVICE                        = UUID.from_16_bits(0x1109, 'CordlessTelephony')
+BT_AUDIO_SOURCE_SERVICE                              = UUID.from_16_bits(0x110A, 'AudioSource')
+BT_AUDIO_SINK_SERVICE                                = UUID.from_16_bits(0x110B, 'AudioSink')
+BT_AV_REMOTE_CONTROL_TARGET_SERVICE                  = UUID.from_16_bits(0x110C, 'A/V_RemoteControlTarget')
+BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE               = UUID.from_16_bits(0x110D, 'AdvancedAudioDistribution')
+BT_AV_REMOTE_CONTROL_SERVICE                         = UUID.from_16_bits(0x110E, 'A/V_RemoteControl')
+BT_AV_REMOTE_CONTROL_CONTROLLER_SERVICE              = UUID.from_16_bits(0x110F, 'A/V_RemoteControlController')
+BT_INTERCOM_SERVICE                                  = UUID.from_16_bits(0x1110, 'Intercom')
+BT_FAX_SERVICE                                       = UUID.from_16_bits(0x1111, 'Fax')
+BT_HEADSET_AUDIO_GATEWAY_SERVICE                     = UUID.from_16_bits(0x1112, 'Headset - Audio Gateway')
+BT_WAP_SERVICE                                       = UUID.from_16_bits(0x1113, 'WAP')
+BT_WAP_CLIENT_SERVICE                                = UUID.from_16_bits(0x1114, 'WAP_CLIENT')
+BT_PANU_SERVICE                                      = UUID.from_16_bits(0x1115, 'PANU')
+BT_NAP_SERVICE                                       = UUID.from_16_bits(0x1116, 'NAP')
+BT_GN_SERVICE                                        = UUID.from_16_bits(0x1117, 'GN')
+BT_DIRECT_PRINTING_SERVICE                           = UUID.from_16_bits(0x1118, 'DirectPrinting')
+BT_REFERENCE_PRINTING_SERVICE                        = UUID.from_16_bits(0x1119, 'ReferencePrinting')
+BT_BASIC_IMAGING_PROFILE_SERVICE                     = UUID.from_16_bits(0x111A, 'Basic Imaging Profile')
+BT_IMAGING_RESPONDER_SERVICE                         = UUID.from_16_bits(0x111B, 'ImagingResponder')
+BT_IMAGING_AUTOMATIC_ARCHIVE_SERVICE                 = UUID.from_16_bits(0x111C, 'ImagingAutomaticArchive')
+BT_IMAGING_REFERENCED_OBJECTS_SERVICE                = UUID.from_16_bits(0x111D, 'ImagingReferencedObjects')
+BT_HANDSFREE_SERVICE                                 = UUID.from_16_bits(0x111E, 'Handsfree')
+BT_HANDSFREE_AUDIO_GATEWAY_SERVICE                   = UUID.from_16_bits(0x111F, 'HandsfreeAudioGateway')
+BT_DIRECT_PRINTING_REFERENCE_OBJECTS_SERVICE         = UUID.from_16_bits(0x1120, 'DirectPrintingReferenceObjectsService')
+BT_REFLECTED_UI_SERVICE                              = UUID.from_16_bits(0x1121, 'ReflectedUI')
+BT_BASIC_PRINTING_SERVICE                            = UUID.from_16_bits(0x1122, 'BasicPrinting')
+BT_PRINTING_STATUS_SERVICE                           = UUID.from_16_bits(0x1123, 'PrintingStatus')
+BT_HUMAN_INTERFACE_DEVICE_SERVICE                    = UUID.from_16_bits(0x1124, 'HumanInterfaceDeviceService')
+BT_HARDCOPY_CABLE_REPLACEMENT_SERVICE                = UUID.from_16_bits(0x1125, 'HardcopyCableReplacement')
+BT_HCR_PRINT_SERVICE                                 = UUID.from_16_bits(0x1126, 'HCR_Print')
+BT_HCR_SCAN_SERVICE                                  = UUID.from_16_bits(0x1127, 'HCR_Scan')
+BT_COMMON_ISDN_ACCESS_SERVICE                        = UUID.from_16_bits(0x1128, 'Common_ISDN_Access')
+BT_SIM_ACCESS_SERVICE                                = UUID.from_16_bits(0x112D, 'SIM_Access')
+BT_PHONEBOOK_ACCESS_PCE_SERVICE                      = UUID.from_16_bits(0x112E, 'Phonebook Access - PCE')
+BT_PHONEBOOK_ACCESS_PSE_SERVICE                      = UUID.from_16_bits(0x112F, 'Phonebook Access - PSE')
+BT_PHONEBOOK_ACCESS_SERVICE                          = UUID.from_16_bits(0x1130, 'Phonebook Access')
+BT_HEADSET_HS_SERVICE                                = UUID.from_16_bits(0x1131, 'Headset - HS')
+BT_MESSAGE_ACCESS_SERVER_SERVICE                     = UUID.from_16_bits(0x1132, 'Message Access Server')
+BT_MESSAGE_NOTIFICATION_SERVER_SERVICE               = UUID.from_16_bits(0x1133, 'Message Notification Server')
+BT_MESSAGE_ACCESS_PROFILE_SERVICE                    = UUID.from_16_bits(0x1134, 'Message Access Profile')
+BT_GNSS_SERVICE                                      = UUID.from_16_bits(0x1135, 'GNSS')
+BT_GNSS_SERVER_SERVICE                               = UUID.from_16_bits(0x1136, 'GNSS_Server')
+BT_3D_DISPLAY_SERVICE                                = UUID.from_16_bits(0x1137, '3D Display')
+BT_3D_GLASSES_SERVICE                                = UUID.from_16_bits(0x1138, '3D Glasses')
+BT_3D_SYNCHRONIZATION_SERVICE                        = UUID.from_16_bits(0x1139, '3D Synchronization')
+BT_MPS_PROFILE_SERVICE                               = UUID.from_16_bits(0x113A, 'MPS Profile')
+BT_MPS_SC_SERVICE                                    = UUID.from_16_bits(0x113B, 'MPS SC')
+BT_ACCESS_SERVICE_SERVICE                            = UUID.from_16_bits(0x113C, 'CTN Access Service')
+BT_CTN_NOTIFICATION_SERVICE_SERVICE                  = UUID.from_16_bits(0x113D, 'CTN Notification Service')
+BT_CTN_PROFILE_SERVICE                               = UUID.from_16_bits(0x113E, 'CTN Profile')
+BT_PNP_INFORMATION_SERVICE                           = UUID.from_16_bits(0x1200, 'PnPInformation')
+BT_GENERIC_NETWORKING_SERVICE                        = UUID.from_16_bits(0x1201, 'GenericNetworking')
+BT_GENERIC_FILE_TRANSFER_SERVICE                     = UUID.from_16_bits(0x1202, 'GenericFileTransfer')
+BT_GENERIC_AUDIO_SERVICE                             = UUID.from_16_bits(0x1203, 'GenericAudio')
+BT_GENERIC_TELEPHONY_SERVICE                         = UUID.from_16_bits(0x1204, 'GenericTelephony')
+BT_UPNP_SERVICE                                      = UUID.from_16_bits(0x1205, 'UPNP_Service')
+BT_UPNP_IP_SERVICE                                   = UUID.from_16_bits(0x1206, 'UPNP_IP_Service')
+BT_ESDP_UPNP_IP_PAN_SERVICE                          = UUID.from_16_bits(0x1300, 'ESDP_UPNP_IP_PAN')
+BT_ESDP_UPNP_IP_LAP_SERVICE                          = UUID.from_16_bits(0x1301, 'ESDP_UPNP_IP_LAP')
+BT_ESDP_UPNP_L2CAP_SERVICE                           = UUID.from_16_bits(0x1302, 'ESDP_UPNP_L2CAP')
+BT_VIDEO_SOURCE_SERVICE                              = UUID.from_16_bits(0x1303, 'VideoSource')
+BT_VIDEO_SINK_SERVICE                                = UUID.from_16_bits(0x1304, 'VideoSink')
+BT_VIDEO_DISTRIBUTION_SERVICE                        = UUID.from_16_bits(0x1305, 'VideoDistribution')
+BT_HDP_SERVICE                                       = UUID.from_16_bits(0x1400, 'HDP')
+BT_HDP_SOURCE_SERVICE                                = UUID.from_16_bits(0x1401, 'HDP Source')
+BT_HDP_SINK_SERVICE                                  = UUID.from_16_bits(0x1402, 'HDP Sink')
+
+# fmt: on
+# pylint: enable=line-too-long
+
+
+# -----------------------------------------------------------------------------
+# DeviceClass
+# -----------------------------------------------------------------------------
+class DeviceClass:
+    # fmt: off
+    # pylint: disable=line-too-long
+
+    # Major Service Classes (flags combined with OR)
+    LIMITED_DISCOVERABLE_MODE_SERVICE_CLASS = (1 << 0)
+    LE_AUDIO_SERVICE_CLASS                  = (1 << 1)
+    RESERVED                                = (1 << 2)
+    POSITIONING_SERVICE_CLASS               = (1 << 3)
+    NETWORKING_SERVICE_CLASS                = (1 << 4)
+    RENDERING_SERVICE_CLASS                 = (1 << 5)
+    CAPTURING_SERVICE_CLASS                 = (1 << 6)
+    OBJECT_TRANSFER_SERVICE_CLASS           = (1 << 7)
+    AUDIO_SERVICE_CLASS                     = (1 << 8)
+    TELEPHONY_SERVICE_CLASS                 = (1 << 9)
+    INFORMATION_SERVICE_CLASS               = (1 << 10)
+
+    SERVICE_CLASS_LABELS = [
+        'Limited Discoverable Mode',
+        'LE audio',
+        '(reserved)',
+        'Positioning',
+        'Networking',
+        'Rendering',
+        'Capturing',
+        'Object Transfer',
+        'Audio',
+        'Telephony',
+        'Information'
+    ]
+
+    # Major Device Classes
+    MISCELLANEOUS_MAJOR_DEVICE_CLASS            = 0x00
+    COMPUTER_MAJOR_DEVICE_CLASS                 = 0x01
+    PHONE_MAJOR_DEVICE_CLASS                    = 0x02
+    LAN_NETWORK_ACCESS_POINT_MAJOR_DEVICE_CLASS = 0x03
+    AUDIO_VIDEO_MAJOR_DEVICE_CLASS              = 0x04
+    PERIPHERAL_MAJOR_DEVICE_CLASS               = 0x05
+    IMAGING_MAJOR_DEVICE_CLASS                  = 0x06
+    WEARABLE_MAJOR_DEVICE_CLASS                 = 0x07
+    TOY_MAJOR_DEVICE_CLASS                      = 0x08
+    HEALTH_MAJOR_DEVICE_CLASS                   = 0x09
+    UNCATEGORIZED_MAJOR_DEVICE_CLASS            = 0x1F
+
+    MAJOR_DEVICE_CLASS_NAMES = {
+        MISCELLANEOUS_MAJOR_DEVICE_CLASS:            'Miscellaneous',
+        COMPUTER_MAJOR_DEVICE_CLASS:                 'Computer',
+        PHONE_MAJOR_DEVICE_CLASS:                    'Phone',
+        LAN_NETWORK_ACCESS_POINT_MAJOR_DEVICE_CLASS: 'LAN/Network Access Point',
+        AUDIO_VIDEO_MAJOR_DEVICE_CLASS:              'Audio/Video',
+        PERIPHERAL_MAJOR_DEVICE_CLASS:               'Peripheral',
+        IMAGING_MAJOR_DEVICE_CLASS:                  'Imaging',
+        WEARABLE_MAJOR_DEVICE_CLASS:                 'Wearable',
+        TOY_MAJOR_DEVICE_CLASS:                      'Toy',
+        HEALTH_MAJOR_DEVICE_CLASS:                   'Health',
+        UNCATEGORIZED_MAJOR_DEVICE_CLASS:            'Uncategorized'
+    }
+
+    COMPUTER_UNCATEGORIZED_MINOR_DEVICE_CLASS         = 0x00
+    COMPUTER_DESKTOP_WORKSTATION_MINOR_DEVICE_CLASS   = 0x01
+    COMPUTER_SERVER_CLASS_COMPUTER_MINOR_DEVICE_CLASS = 0x02
+    COMPUTER_LAPTOP_COMPUTER_MINOR_DEVICE_CLASS       = 0x03
+    COMPUTER_HANDHELD_PC_PDA_MINOR_DEVICE_CLASS       = 0x04
+    COMPUTER_PALM_SIZE_PC_PDA_MINOR_DEVICE_CLASS      = 0x05
+    COMPUTER_WEARABLE_COMPUTER_MINOR_DEVICE_CLASS     = 0x06
+    COMPUTER_TABLET_MINOR_DEVICE_CLASS                = 0x07
+
+    COMPUTER_MINOR_DEVICE_CLASS_NAMES = {
+        COMPUTER_UNCATEGORIZED_MINOR_DEVICE_CLASS:         'Uncategorized',
+        COMPUTER_DESKTOP_WORKSTATION_MINOR_DEVICE_CLASS:   'Desktop workstation',
+        COMPUTER_SERVER_CLASS_COMPUTER_MINOR_DEVICE_CLASS: 'Server-class computer',
+        COMPUTER_LAPTOP_COMPUTER_MINOR_DEVICE_CLASS:       'Laptop',
+        COMPUTER_HANDHELD_PC_PDA_MINOR_DEVICE_CLASS:       'Handheld PC/PDA',
+        COMPUTER_PALM_SIZE_PC_PDA_MINOR_DEVICE_CLASS:      'Palm-size PC/PDA',
+        COMPUTER_WEARABLE_COMPUTER_MINOR_DEVICE_CLASS:     'Wearable computer',
+        COMPUTER_TABLET_MINOR_DEVICE_CLASS:                'Tablet'
+    }
+
+    PHONE_UNCATEGORIZED_MINOR_DEVICE_CLASS                = 0x00
+    PHONE_CELLULAR_MINOR_DEVICE_CLASS                     = 0x01
+    PHONE_CORDLESS_MINOR_DEVICE_CLASS                     = 0x02
+    PHONE_SMARTPHONE_MINOR_DEVICE_CLASS                   = 0x03
+    PHONE_WIRED_MODEM_OR_VOICE_GATEWAY_MINOR_DEVICE_CLASS = 0x04
+    PHONE_COMMON_ISDN_MINOR_DEVICE_CLASS                  = 0x05
+
+    PHONE_MINOR_DEVICE_CLASS_NAMES = {
+        PHONE_UNCATEGORIZED_MINOR_DEVICE_CLASS:                'Uncategorized',
+        PHONE_CELLULAR_MINOR_DEVICE_CLASS:                     'Cellular',
+        PHONE_CORDLESS_MINOR_DEVICE_CLASS:                     'Cordless',
+        PHONE_SMARTPHONE_MINOR_DEVICE_CLASS:                   'Smartphone',
+        PHONE_WIRED_MODEM_OR_VOICE_GATEWAY_MINOR_DEVICE_CLASS: 'Wired modem or voice gateway',
+        PHONE_COMMON_ISDN_MINOR_DEVICE_CLASS:                  'Common ISDN access'
+    }
+
+    AUDIO_VIDEO_UNCATEGORIZED_MINOR_DEVICE_CLASS                 = 0x00
+    AUDIO_VIDEO_WEARABLE_HEADSET_DEVICE_MINOR_DEVICE_CLASS       = 0x01
+    AUDIO_VIDEO_HANDS_FREE_DEVICE_MINOR_DEVICE_CLASS             = 0x02
+    # (RESERVED)                                                 = 0x03
+    AUDIO_VIDEO_MICROPHONE_MINOR_DEVICE_CLASS                    = 0x04
+    AUDIO_VIDEO_LOUDSPEAKER_MINOR_DEVICE_CLASS                   = 0x05
+    AUDIO_VIDEO_HEADPHONES_MINOR_DEVICE_CLASS                    = 0x06
+    AUDIO_VIDEO_PORTABLE_AUDIO_MINOR_DEVICE_CLASS                = 0x07
+    AUDIO_VIDEO_CAR_AUDIO_MINOR_DEVICE_CLASS                     = 0x08
+    AUDIO_VIDEO_SET_TOP_BOX_MINOR_DEVICE_CLASS                   = 0x09
+    AUDIO_VIDEO_HIFI_AUDIO_DEVICE_MINOR_DEVICE_CLASS             = 0x0A
+    AUDIO_VIDEO_VCR_MINOR_DEVICE_CLASS                           = 0x0B
+    AUDIO_VIDEO_VIDEO_CAMERA_MINOR_DEVICE_CLASS                  = 0x0C
+    AUDIO_VIDEO_CAMCORDER_MINOR_DEVICE_CLASS                     = 0x0D
+    AUDIO_VIDEO_VIDEO_MONITOR_MINOR_DEVICE_CLASS                 = 0x0E
+    AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER_MINOR_DEVICE_CLASS = 0x0F
+    AUDIO_VIDEO_VIDEO_CONFERENCING_MINOR_DEVICE_CLASS            = 0x10
+    # (RESERVED)                                                 = 0x11
+    AUDIO_VIDEO_GAMING_OR_TOY_MINOR_DEVICE_CLASS                 = 0x12
+
+    AUDIO_VIDEO_MINOR_DEVICE_CLASS_NAMES = {
+        AUDIO_VIDEO_UNCATEGORIZED_MINOR_DEVICE_CLASS:                 'Uncategorized',
+        AUDIO_VIDEO_WEARABLE_HEADSET_DEVICE_MINOR_DEVICE_CLASS:       'Wearable Headset Device',
+        AUDIO_VIDEO_HANDS_FREE_DEVICE_MINOR_DEVICE_CLASS:             'Hands-free Device',
+        AUDIO_VIDEO_MICROPHONE_MINOR_DEVICE_CLASS:                    'Microphone',
+        AUDIO_VIDEO_LOUDSPEAKER_MINOR_DEVICE_CLASS:                   'Loudspeaker',
+        AUDIO_VIDEO_HEADPHONES_MINOR_DEVICE_CLASS:                    'Headphones',
+        AUDIO_VIDEO_PORTABLE_AUDIO_MINOR_DEVICE_CLASS:                'Portable Audio',
+        AUDIO_VIDEO_CAR_AUDIO_MINOR_DEVICE_CLASS:                     'Car audio',
+        AUDIO_VIDEO_SET_TOP_BOX_MINOR_DEVICE_CLASS:                   'Set-top box',
+        AUDIO_VIDEO_HIFI_AUDIO_DEVICE_MINOR_DEVICE_CLASS:             'HiFi Audio Device',
+        AUDIO_VIDEO_VCR_MINOR_DEVICE_CLASS:                           'VCR',
+        AUDIO_VIDEO_VIDEO_CAMERA_MINOR_DEVICE_CLASS:                  'Video Camera',
+        AUDIO_VIDEO_CAMCORDER_MINOR_DEVICE_CLASS:                     'Camcorder',
+        AUDIO_VIDEO_VIDEO_MONITOR_MINOR_DEVICE_CLASS:                 'Video Monitor',
+        AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER_MINOR_DEVICE_CLASS: 'Video Display and Loudspeaker',
+        AUDIO_VIDEO_VIDEO_CONFERENCING_MINOR_DEVICE_CLASS:            'Video Conferencing',
+        AUDIO_VIDEO_GAMING_OR_TOY_MINOR_DEVICE_CLASS:                 'Gaming/Toy'
+    }
+
+    PERIPHERAL_UNCATEGORIZED_MINOR_DEVICE_CLASS                  = 0x00
+    PERIPHERAL_KEYBOARD_MINOR_DEVICE_CLASS                       = 0x10
+    PERIPHERAL_POINTING_DEVICE_MINOR_DEVICE_CLASS                = 0x20
+    PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE_MINOR_DEVICE_CLASS = 0x30
+    PERIPHERAL_JOYSTICK_MINOR_DEVICE_CLASS                       = 0x01
+    PERIPHERAL_GAMEPAD_MINOR_DEVICE_CLASS                        = 0x02
+    PERIPHERAL_REMOTE_CONTROL_MINOR_DEVICE_CLASS                 = 0x03
+    PERIPHERAL_SENSING_DEVICE_MINOR_DEVICE_CLASS                 = 0x04
+    PERIPHERAL_DIGITIZER_TABLET_MINOR_DEVICE_CLASS               = 0x05
+    PERIPHERAL_CARD_READER_MINOR_DEVICE_CLASS                    = 0x06
+    PERIPHERAL_DIGITAL_PEN_MINOR_DEVICE_CLASS                    = 0x07
+    PERIPHERAL_HANDHELD_SCANNER_MINOR_DEVICE_CLASS               = 0x08
+    PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE_MINOR_DEVICE_CLASS = 0x09
+
+    PERIPHERAL_MINOR_DEVICE_CLASS_NAMES = {
+        PERIPHERAL_UNCATEGORIZED_MINOR_DEVICE_CLASS:                  'Uncategorized',
+        PERIPHERAL_KEYBOARD_MINOR_DEVICE_CLASS:                       'Keyboard',
+        PERIPHERAL_POINTING_DEVICE_MINOR_DEVICE_CLASS:                'Pointing device',
+        PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE_MINOR_DEVICE_CLASS: 'Combo keyboard/pointing device',
+        PERIPHERAL_JOYSTICK_MINOR_DEVICE_CLASS:                       'Joystick',
+        PERIPHERAL_GAMEPAD_MINOR_DEVICE_CLASS:                        'Gamepad',
+        PERIPHERAL_REMOTE_CONTROL_MINOR_DEVICE_CLASS:                 'Remote control',
+        PERIPHERAL_SENSING_DEVICE_MINOR_DEVICE_CLASS:                 'Sensing device',
+        PERIPHERAL_DIGITIZER_TABLET_MINOR_DEVICE_CLASS:               'Digitizer tablet',
+        PERIPHERAL_CARD_READER_MINOR_DEVICE_CLASS:                    'Card Reader',
+        PERIPHERAL_DIGITAL_PEN_MINOR_DEVICE_CLASS:                    'Digital Pen',
+        PERIPHERAL_HANDHELD_SCANNER_MINOR_DEVICE_CLASS:               'Handheld scanner',
+        PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE_MINOR_DEVICE_CLASS: 'Handheld gestural input device'
+    }
+
+    MINOR_DEVICE_CLASS_NAMES = {
+        COMPUTER_MAJOR_DEVICE_CLASS:    COMPUTER_MINOR_DEVICE_CLASS_NAMES,
+        PHONE_MAJOR_DEVICE_CLASS:       PHONE_MINOR_DEVICE_CLASS_NAMES,
+        AUDIO_VIDEO_MAJOR_DEVICE_CLASS: AUDIO_VIDEO_MINOR_DEVICE_CLASS_NAMES,
+        PERIPHERAL_MAJOR_DEVICE_CLASS:  PERIPHERAL_MINOR_DEVICE_CLASS_NAMES
+    }
+
+    # fmt: on
+    # pylint: enable=line-too-long
+
+    @staticmethod
+    def split_class_of_device(class_of_device):
+        # Split the bit fields of the composite class of device value into:
+        # (service_classes, major_device_class, minor_device_class)
+        return (
+            (class_of_device >> 13 & 0x7FF),
+            (class_of_device >> 8 & 0x1F),
+            (class_of_device >> 2 & 0x3F),
+        )
+
+    @staticmethod
+    def pack_class_of_device(service_classes, major_device_class, minor_device_class):
+        return service_classes << 13 | major_device_class << 8 | minor_device_class << 2
+
+    @staticmethod
+    def service_class_labels(service_class_flags):
+        return bit_flags_to_strings(
+            service_class_flags, DeviceClass.SERVICE_CLASS_LABELS
+        )
+
+    @staticmethod
+    def major_device_class_name(device_class):
+        return name_or_number(DeviceClass.MAJOR_DEVICE_CLASS_NAMES, device_class)
+
+    @staticmethod
+    def minor_device_class_name(major_device_class, minor_device_class):
+        class_names = DeviceClass.MINOR_DEVICE_CLASS_NAMES.get(major_device_class)
+        if class_names is None:
+            return f'#{minor_device_class:02X}'
+        return name_or_number(class_names, minor_device_class)
+
+
+# -----------------------------------------------------------------------------
+# Advertising Data
+# -----------------------------------------------------------------------------
+class AdvertisingData:
+    # fmt: off
+    # pylint: disable=line-too-long
+
+    # This list is only partial, it still needs to be filled in from the spec
+    FLAGS                                          = 0x01
+    INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS  = 0x02
+    COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS    = 0x03
+    INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS  = 0x04
+    COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS    = 0x05
+    INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS = 0x06
+    COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS   = 0x07
+    SHORTENED_LOCAL_NAME                           = 0x08
+    COMPLETE_LOCAL_NAME                            = 0x09
+    TX_POWER_LEVEL                                 = 0x0A
+    CLASS_OF_DEVICE                                = 0x0D
+    SIMPLE_PAIRING_HASH_C                          = 0x0E
+    SIMPLE_PAIRING_HASH_C_192                      = 0x0E
+    SIMPLE_PAIRING_RANDOMIZER_R                    = 0x0F
+    SIMPLE_PAIRING_RANDOMIZER_R_192                = 0x0F
+    DEVICE_ID                                      = 0x10
+    SECURITY_MANAGER_TK_VALUE                      = 0x10
+    SECURITY_MANAGER_OUT_OF_BAND_FLAGS             = 0x11
+    PERIPHERAL_CONNECTION_INTERVAL_RANGE           = 0x12
+    LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS      = 0x14
+    LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS     = 0x15
+    SERVICE_DATA                                   = 0x16
+    SERVICE_DATA_16_BIT_UUID                       = 0x16
+    PUBLIC_TARGET_ADDRESS                          = 0x17
+    RANDOM_TARGET_ADDRESS                          = 0x18
+    APPEARANCE                                     = 0x19
+    ADVERTISING_INTERVAL                           = 0x1A
+    LE_BLUETOOTH_DEVICE_ADDRESS                    = 0x1B
+    LE_ROLE                                        = 0x1C
+    SIMPLE_PAIRING_HASH_C_256                      = 0x1D
+    SIMPLE_PAIRING_RANDOMIZER_R_256                = 0x1E
+    LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS      = 0x1F
+    SERVICE_DATA_32_BIT_UUID                       = 0x20
+    SERVICE_DATA_128_BIT_UUID                      = 0x21
+    LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE       = 0x22
+    LE_SECURE_CONNECTIONS_RANDOM_VALUE             = 0x23
+    URI                                            = 0x24
+    INDOOR_POSITIONING                             = 0x25
+    TRANSPORT_DISCOVERY_DATA                       = 0x26
+    LE_SUPPORTED_FEATURES                          = 0x27
+    CHANNEL_MAP_UPDATE_INDICATION                  = 0x28
+    PB_ADV                                         = 0x29
+    MESH_MESSAGE                                   = 0x2A
+    MESH_BEACON                                    = 0x2B
+    BIGINFO                                        = 0x2C
+    BROADCAST_CODE                                 = 0x2D
+    RESOLVABLE_SET_IDENTIFIER                      = 0x2E
+    ADVERTISING_INTERVAL_LONG                      = 0x2F
+    THREE_D_INFORMATION_DATA                       = 0x3D
+    MANUFACTURER_SPECIFIC_DATA                     = 0xFF
+
+    AD_TYPE_NAMES = {
+        FLAGS:                                          'FLAGS',
+        INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:  'INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS',
+        COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:    'COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS',
+        INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:  'INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS',
+        COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:    'COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS',
+        INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: 'INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS',
+        COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:   'COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS',
+        SHORTENED_LOCAL_NAME:                           'SHORTENED_LOCAL_NAME',
+        COMPLETE_LOCAL_NAME:                            'COMPLETE_LOCAL_NAME',
+        TX_POWER_LEVEL:                                 'TX_POWER_LEVEL',
+        CLASS_OF_DEVICE:                                'CLASS_OF_DEVICE',
+        SIMPLE_PAIRING_HASH_C:                          'SIMPLE_PAIRING_HASH_C',
+        SIMPLE_PAIRING_HASH_C_192:                      'SIMPLE_PAIRING_HASH_C_192',
+        SIMPLE_PAIRING_RANDOMIZER_R:                    'SIMPLE_PAIRING_RANDOMIZER_R',
+        SIMPLE_PAIRING_RANDOMIZER_R_192:                'SIMPLE_PAIRING_RANDOMIZER_R_192',
+        DEVICE_ID:                                      'DEVICE_ID',
+        SECURITY_MANAGER_TK_VALUE:                      'SECURITY_MANAGER_TK_VALUE',
+        SECURITY_MANAGER_OUT_OF_BAND_FLAGS:             'SECURITY_MANAGER_OUT_OF_BAND_FLAGS',
+        PERIPHERAL_CONNECTION_INTERVAL_RANGE:           'PERIPHERAL_CONNECTION_INTERVAL_RANGE',
+        LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS:      'LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS',
+        LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS:     'LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS',
+        SERVICE_DATA:                                   'SERVICE_DATA',
+        SERVICE_DATA_16_BIT_UUID:                       'SERVICE_DATA_16_BIT_UUID',
+        PUBLIC_TARGET_ADDRESS:                          'PUBLIC_TARGET_ADDRESS',
+        RANDOM_TARGET_ADDRESS:                          'RANDOM_TARGET_ADDRESS',
+        APPEARANCE:                                     'APPEARANCE',
+        ADVERTISING_INTERVAL:                           'ADVERTISING_INTERVAL',
+        LE_BLUETOOTH_DEVICE_ADDRESS:                    'LE_BLUETOOTH_DEVICE_ADDRESS',
+        LE_ROLE:                                        'LE_ROLE',
+        SIMPLE_PAIRING_HASH_C_256:                      'SIMPLE_PAIRING_HASH_C_256',
+        SIMPLE_PAIRING_RANDOMIZER_R_256:                'SIMPLE_PAIRING_RANDOMIZER_R_256',
+        LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS:      'LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS',
+        SERVICE_DATA_32_BIT_UUID:                       'SERVICE_DATA_32_BIT_UUID',
+        SERVICE_DATA_128_BIT_UUID:                      'SERVICE_DATA_128_BIT_UUID',
+        LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE:       'LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE',
+        LE_SECURE_CONNECTIONS_RANDOM_VALUE:             'LE_SECURE_CONNECTIONS_RANDOM_VALUE',
+        URI:                                            'URI',
+        INDOOR_POSITIONING:                             'INDOOR_POSITIONING',
+        TRANSPORT_DISCOVERY_DATA:                       'TRANSPORT_DISCOVERY_DATA',
+        LE_SUPPORTED_FEATURES:                          'LE_SUPPORTED_FEATURES',
+        CHANNEL_MAP_UPDATE_INDICATION:                  'CHANNEL_MAP_UPDATE_INDICATION',
+        PB_ADV:                                         'PB_ADV',
+        MESH_MESSAGE:                                   'MESH_MESSAGE',
+        MESH_BEACON:                                    'MESH_BEACON',
+        BIGINFO:                                        'BIGINFO',
+        BROADCAST_CODE:                                 'BROADCAST_CODE',
+        RESOLVABLE_SET_IDENTIFIER:                      'RESOLVABLE_SET_IDENTIFIER',
+        ADVERTISING_INTERVAL_LONG:                      'ADVERTISING_INTERVAL_LONG',
+        THREE_D_INFORMATION_DATA:                       'THREE_D_INFORMATION_DATA',
+        MANUFACTURER_SPECIFIC_DATA:                     'MANUFACTURER_SPECIFIC_DATA'
+    }
+
+    LE_LIMITED_DISCOVERABLE_MODE_FLAG = 0x01
+    LE_GENERAL_DISCOVERABLE_MODE_FLAG = 0x02
+    BR_EDR_NOT_SUPPORTED_FLAG         = 0x04
+    BR_EDR_CONTROLLER_FLAG            = 0x08
+    BR_EDR_HOST_FLAG                  = 0x10
+
+    # fmt: on
+    # pylint: enable=line-too-long
+
+    def __init__(self, ad_structures=None):
+        if ad_structures is None:
+            ad_structures = []
+        self.ad_structures = ad_structures[:]
+
+    @staticmethod
+    def from_bytes(data):
+        instance = AdvertisingData()
+        instance.append(data)
+        return instance
+
+    @staticmethod
+    def flags_to_string(flags, short=False):
+        flag_names = (
+            ['LE Limited', 'LE General', 'No BR/EDR', 'BR/EDR C', 'BR/EDR H']
+            if short
+            else [
+                'LE Limited Discoverable Mode',
+                'LE General Discoverable Mode',
+                'BR/EDR Not Supported',
+                'Simultaneous LE and BR/EDR (Controller)',
+                'Simultaneous LE and BR/EDR (Host)',
+            ]
+        )
+        return ','.join(bit_flags_to_strings(flags, flag_names))
+
+    @staticmethod
+    def uuid_list_to_objects(ad_data, uuid_size):
+        uuids = []
+        offset = 0
+        while (uuid_size * (offset + 1)) <= len(ad_data):
+            uuids.append(UUID.from_bytes(ad_data[offset : offset + uuid_size]))
+            offset += uuid_size
+        return uuids
+
+    @staticmethod
+    def uuid_list_to_string(ad_data, uuid_size):
+        return ', '.join(
+            [
+                str(uuid)
+                for uuid in AdvertisingData.uuid_list_to_objects(ad_data, uuid_size)
+            ]
+        )
+
+    @staticmethod
+    def ad_data_to_string(ad_type, ad_data):
+        if ad_type == AdvertisingData.FLAGS:
+            ad_type_str = 'Flags'
+            ad_data_str = AdvertisingData.flags_to_string(ad_data[0], short=True)
+        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Complete List of 16-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 2)
+        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Incomplete List of 16-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 2)
+        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Complete List of 32-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 4)
+        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Incomplete List of 32-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 4)
+        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Complete List of 128-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 16)
+        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Incomplete List of 128-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 16)
+        elif ad_type == AdvertisingData.SERVICE_DATA_16_BIT_UUID:
+            ad_type_str = 'Service Data'
+            uuid = UUID.from_bytes(ad_data[:2])
+            ad_data_str = f'service={uuid}, data={ad_data[2:].hex()}'
+        elif ad_type == AdvertisingData.SERVICE_DATA_32_BIT_UUID:
+            ad_type_str = 'Service Data'
+            uuid = UUID.from_bytes(ad_data[:4])
+            ad_data_str = f'service={uuid}, data={ad_data[4:].hex()}'
+        elif ad_type == AdvertisingData.SERVICE_DATA_128_BIT_UUID:
+            ad_type_str = 'Service Data'
+            uuid = UUID.from_bytes(ad_data[:16])
+            ad_data_str = f'service={uuid}, data={ad_data[16:].hex()}'
+        elif ad_type == AdvertisingData.SHORTENED_LOCAL_NAME:
+            ad_type_str = 'Shortened Local Name'
+            ad_data_str = f'"{ad_data.decode("utf-8")}"'
+        elif ad_type == AdvertisingData.COMPLETE_LOCAL_NAME:
+            ad_type_str = 'Complete Local Name'
+            ad_data_str = f'"{ad_data.decode("utf-8")}"'
+        elif ad_type == AdvertisingData.TX_POWER_LEVEL:
+            ad_type_str = 'TX Power Level'
+            ad_data_str = str(ad_data[0])
+        elif ad_type == AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
+            ad_type_str = 'Manufacturer Specific Data'
+            company_id = struct.unpack_from('<H', ad_data, 0)[0]
+            company_name = COMPANY_IDENTIFIERS.get(company_id, f'0x{company_id:04X}')
+            ad_data_str = f'company={company_name}, data={ad_data[2:].hex()}'
+        elif ad_type == AdvertisingData.APPEARANCE:
+            ad_type_str = 'Appearance'
+            ad_data_str = ad_data.hex()
+        else:
+            ad_type_str = AdvertisingData.AD_TYPE_NAMES.get(ad_type, f'0x{ad_type:02X}')
+            ad_data_str = ad_data.hex()
+
+        return f'[{ad_type_str}]: {ad_data_str}'
+
+    # pylint: disable=too-many-return-statements
+    @staticmethod
+    def ad_data_to_object(ad_type, ad_data):
+        if ad_type in (
+            AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS,
+        ):
+            return AdvertisingData.uuid_list_to_objects(ad_data, 2)
+
+        if ad_type in (
+            AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS,
+        ):
+            return AdvertisingData.uuid_list_to_objects(ad_data, 4)
+
+        if ad_type in (
+            AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS,
+        ):
+            return AdvertisingData.uuid_list_to_objects(ad_data, 16)
+
+        if ad_type == AdvertisingData.SERVICE_DATA_16_BIT_UUID:
+            return (UUID.from_bytes(ad_data[:2]), ad_data[2:])
+
+        if ad_type == AdvertisingData.SERVICE_DATA_32_BIT_UUID:
+            return (UUID.from_bytes(ad_data[:4]), ad_data[4:])
+
+        if ad_type == AdvertisingData.SERVICE_DATA_128_BIT_UUID:
+            return (UUID.from_bytes(ad_data[:16]), ad_data[16:])
+
+        if ad_type in (
+            AdvertisingData.SHORTENED_LOCAL_NAME,
+            AdvertisingData.COMPLETE_LOCAL_NAME,
+            AdvertisingData.URI,
+        ):
+            return ad_data.decode("utf-8")
+
+        if ad_type in (AdvertisingData.TX_POWER_LEVEL, AdvertisingData.FLAGS):
+            return ad_data[0]
+
+        if ad_type in (
+            AdvertisingData.APPEARANCE,
+            AdvertisingData.ADVERTISING_INTERVAL,
+        ):
+            return struct.unpack('<H', ad_data)[0]
+
+        if ad_type == AdvertisingData.CLASS_OF_DEVICE:
+            return struct.unpack('<I', bytes([*ad_data, 0]))[0]
+
+        if ad_type == AdvertisingData.PERIPHERAL_CONNECTION_INTERVAL_RANGE:
+            return struct.unpack('<HH', ad_data)
+
+        if ad_type == AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
+            return (struct.unpack_from('<H', ad_data, 0)[0], ad_data[2:])
+
+        return ad_data
+
+    def append(self, data):
+        offset = 0
+        while offset + 1 < len(data):
+            length = data[offset]
+            offset += 1
+            if length > 0:
+                ad_type = data[offset]
+                ad_data = data[offset + 1 : offset + length]
+                self.ad_structures.append((ad_type, ad_data))
+            offset += length
+
+    def get(self, type_id, return_all=False, raw=False):
+        '''
+        Get Advertising Data Structure(s) with a given type
+
+        If return_all is True, returns a (possibly empty) list of matches,
+        else returns the first entry, or None if no structure matches.
+        '''
+
+        def process_ad_data(ad_data):
+            return ad_data if raw else self.ad_data_to_object(type_id, ad_data)
+
+        if return_all:
+            return [
+                process_ad_data(ad[1]) for ad in self.ad_structures if ad[0] == type_id
+            ]
+
+        return next(
+            (process_ad_data(ad[1]) for ad in self.ad_structures if ad[0] == type_id),
+            None,
+        )
+
+    def __bytes__(self):
+        return b''.join(
+            [bytes([len(x[1]) + 1, x[0]]) + x[1] for x in self.ad_structures]
+        )
+
+    def to_string(self, separator=', '):
+        return separator.join(
+            [AdvertisingData.ad_data_to_string(x[0], x[1]) for x in self.ad_structures]
+        )
+
+    def __str__(self):
+        return self.to_string()
+
+
+# -----------------------------------------------------------------------------
+# Connection Parameters
+# -----------------------------------------------------------------------------
+class ConnectionParameters:
+    def __init__(self, connection_interval, peripheral_latency, supervision_timeout):
+        self.connection_interval = connection_interval
+        self.peripheral_latency = peripheral_latency
+        self.supervision_timeout = supervision_timeout
+
+    def __str__(self):
+        return (
+            f'ConnectionParameters(connection_interval={self.connection_interval}, '
+            f'peripheral_latency={self.peripheral_latency}, '
+            f'supervision_timeout={self.supervision_timeout}'
+        )
+
+
+# -----------------------------------------------------------------------------
+# Connection PHY
+# -----------------------------------------------------------------------------
+class ConnectionPHY:
+    def __init__(self, tx_phy, rx_phy):
+        self.tx_phy = tx_phy
+        self.rx_phy = rx_phy
+
+    def __str__(self):
+        return f'ConnectionPHY(tx_phy={self.tx_phy}, rx_phy={self.rx_phy})'

bumble/crypto.py

@@ -0,0 +1,277 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Crypto support
+#
+# See Bluetooth spec Vol 3, Part H - 2.2 CRYPTOGRAPHIC TOOLBOX
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import operator
+import platform
+
+if platform.system() != 'Emscripten':
+    import secrets
+    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+    from cryptography.hazmat.primitives.asymmetric.ec import (
+        generate_private_key,
+        ECDH,
+        EllipticCurvePublicNumbers,
+        EllipticCurvePrivateNumbers,
+        SECP256R1,
+    )
+    from cryptography.hazmat.primitives import cmac
+else:
+    # TODO: implement stubs
+    pass
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+class EccKey:
+    def __init__(self, private_key):
+        self.private_key = private_key
+
+    @classmethod
+    def generate(cls):
+        private_key = generate_private_key(SECP256R1())
+        return cls(private_key)
+
+    @classmethod
+    def from_private_key_bytes(cls, d_bytes, x_bytes, y_bytes):
+        d = int.from_bytes(d_bytes, byteorder='big', signed=False)
+        x = int.from_bytes(x_bytes, byteorder='big', signed=False)
+        y = int.from_bytes(y_bytes, byteorder='big', signed=False)
+        private_key = EllipticCurvePrivateNumbers(
+            d, EllipticCurvePublicNumbers(x, y, SECP256R1())
+        ).private_key()
+        return cls(private_key)
+
+    @property
+    def x(self):
+        return (
+            self.private_key.public_key()
+            .public_numbers()
+            .x.to_bytes(32, byteorder='big')
+        )
+
+    @property
+    def y(self):
+        return (
+            self.private_key.public_key()
+            .public_numbers()
+            .y.to_bytes(32, byteorder='big')
+        )
+
+    def dh(self, public_key_x, public_key_y):
+        x = int.from_bytes(public_key_x, byteorder='big', signed=False)
+        y = int.from_bytes(public_key_y, byteorder='big', signed=False)
+        public_key = EllipticCurvePublicNumbers(x, y, SECP256R1()).public_key()
+        shared_key = self.private_key.exchange(ECDH(), public_key)
+
+        return shared_key
+
+
+# -----------------------------------------------------------------------------
+# Functions
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+def xor(x, y):
+    assert len(x) == len(y)
+    return bytes(map(operator.xor, x, y))
+
+
+# -----------------------------------------------------------------------------
+def r():
+    '''
+    Generate 16 bytes of random data
+    '''
+    return secrets.token_bytes(16)
+
+
+# -----------------------------------------------------------------------------
+def e(key, data):
+    '''
+    AES-128 ECB, expecting byte-swapped inputs and producing a byte-swapped output.
+
+    See Bluetooth spec Vol 3, Part H - 2.2.1 Security function e
+    '''
+
+    cipher = Cipher(algorithms.AES(bytes(reversed(key))), modes.ECB())
+    encryptor = cipher.encryptor()
+    return bytes(reversed(encryptor.update(bytes(reversed(data)))))
+
+
+# -----------------------------------------------------------------------------
+def ah(k, r):  # pylint: disable=redefined-outer-name
+    '''
+    See Bluetooth spec Vol 3, Part H - 2.2.2 Random Address Hash function ah
+    '''
+
+    padding = bytes(13)
+    r_prime = r + padding
+    return e(k, r_prime)[0:3]
+
+
+# -----------------------------------------------------------------------------
+def c1(k, r, preq, pres, iat, rat, ia, ra):  # pylint: disable=redefined-outer-name
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.3 Confirm value generation function c1 for
+    LE Legacy Pairing
+    '''
+
+    p1 = bytes([iat, rat]) + preq + pres
+    p2 = ra + ia + bytes([0, 0, 0, 0])
+    return e(k, xor(e(k, xor(r, p1)), p2))
+
+
+# -----------------------------------------------------------------------------
+def s1(k, r1, r2):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.4 Key generation function s1 for LE Legacy
+    Pairing
+    '''
+
+    return e(k, r2[0:8] + r1[0:8])
+
+
+# -----------------------------------------------------------------------------
+def aes_cmac(m, k):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.5 FunctionAES-CMAC
+
+    NOTE: the input and output of this internal function are in big-endian byte order
+    '''
+    mac = cmac.CMAC(algorithms.AES(k))
+    mac.update(m)
+    return mac.finalize()
+
+
+# -----------------------------------------------------------------------------
+def f4(u, v, x, z):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.6 LE Secure Connections Confirm Value
+    Generation Function f4
+    '''
+    return bytes(
+        reversed(
+            aes_cmac(bytes(reversed(u)) + bytes(reversed(v)) + z, bytes(reversed(x)))
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+def f5(w, n1, n2, a1, a2):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.7 LE Secure Connections Key Generation
+    Function f5
+
+    NOTE: this returns a tuple: (MacKey, LTK) in little-endian byte order
+    '''
+    salt = bytes.fromhex('6C888391AAF5A53860370BDB5A6083BE')
+    t = aes_cmac(bytes(reversed(w)), salt)
+    key_id = bytes([0x62, 0x74, 0x6C, 0x65])
+    return (
+        bytes(
+            reversed(
+                aes_cmac(
+                    bytes([0])
+                    + key_id
+                    + bytes(reversed(n1))
+                    + bytes(reversed(n2))
+                    + bytes(reversed(a1))
+                    + bytes(reversed(a2))
+                    + bytes([1, 0]),
+                    t,
+                )
+            )
+        ),
+        bytes(
+            reversed(
+                aes_cmac(
+                    bytes([1])
+                    + key_id
+                    + bytes(reversed(n1))
+                    + bytes(reversed(n2))
+                    + bytes(reversed(a1))
+                    + bytes(reversed(a2))
+                    + bytes([1, 0]),
+                    t,
+                )
+            )
+        ),
+    )
+
+
+# -----------------------------------------------------------------------------
+def f6(w, n1, n2, r, io_cap, a1, a2):  # pylint: disable=redefined-outer-name
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.8 LE Secure Connections Check Value
+    Generation Function f6
+    '''
+    return bytes(
+        reversed(
+            aes_cmac(
+                bytes(reversed(n1))
+                + bytes(reversed(n2))
+                + bytes(reversed(r))
+                + bytes(reversed(io_cap))
+                + bytes(reversed(a1))
+                + bytes(reversed(a2)),
+                bytes(reversed(w)),
+            )
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+def g2(u, v, x, y):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.9 LE Secure Connections Numeric Comparison
+    Value Generation Function g2
+    '''
+    return int.from_bytes(
+        aes_cmac(
+            bytes(reversed(u)) + bytes(reversed(v)) + bytes(reversed(y)),
+            bytes(reversed(x)),
+        )[-4:],
+        byteorder='big',
+    )
+
+
+# -----------------------------------------------------------------------------
+def h6(w, key_id):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.10 Link key conversion function h6
+    '''
+    return aes_cmac(key_id, w)
+
+
+# -----------------------------------------------------------------------------
+def h7(salt, w):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.11 Link key conversion function h7
+    '''
+    return aes_cmac(w, salt)

bumble/gap.py

@@ -0,0 +1,59 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import struct
+
+from .gatt import (
+    Service,
+    Characteristic,
+    GATT_GENERIC_ACCESS_SERVICE,
+    GATT_DEVICE_NAME_CHARACTERISTIC,
+    GATT_APPEARANCE_CHARACTERISTIC,
+)
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+class GenericAccessService(Service):
+    def __init__(self, device_name, appearance=(0, 0)):
+        device_name_characteristic = Characteristic(
+            GATT_DEVICE_NAME_CHARACTERISTIC,
+            Characteristic.READ,
+            Characteristic.READABLE,
+            device_name.encode('utf-8')[:248],
+        )
+
+        appearance_characteristic = Characteristic(
+            GATT_APPEARANCE_CHARACTERISTIC,
+            Characteristic.READ,
+            Characteristic.READABLE,
+            struct.pack('<H', (appearance[0] << 6) | appearance[1]),
+        )
+
+        super().__init__(
+            GATT_GENERIC_ACCESS_SERVICE,
+            [device_name_characteristic, appearance_characteristic],
+        )

bumble/gatt.py

@@ -0,0 +1,584 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# GATT - Generic Attribute Profile
+#
+# See Bluetooth spec @ Vol 3, Part G
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+import asyncio
+import enum
+import functools
+import logging
+import struct
+from typing import Sequence
+from colors import color
+
+from .core import UUID, get_dict_key_by_value
+from .att import Attribute
+
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+# fmt: off
+# pylint: disable=line-too-long
+
+GATT_REQUEST_TIMEOUT = 30  # seconds
+
+GATT_MAX_ATTRIBUTE_VALUE_SIZE = 512
+
+# Services
+GATT_GENERIC_ACCESS_SERVICE                 = UUID.from_16_bits(0x1800, 'Generic Access')
+GATT_GENERIC_ATTRIBUTE_SERVICE              = UUID.from_16_bits(0x1801, 'Generic Attribute')
+GATT_IMMEDIATE_ALERT_SERVICE                = UUID.from_16_bits(0x1802, 'Immediate Alert')
+GATT_LINK_LOSS_SERVICE                      = UUID.from_16_bits(0x1803, 'Link Loss')
+GATT_TX_POWER_SERVICE                       = UUID.from_16_bits(0x1804, 'TX Power')
+GATT_CURRENT_TIME_SERVICE                   = UUID.from_16_bits(0x1805, 'Current Time')
+GATT_REFERENCE_TIME_UPDATE_SERVICE          = UUID.from_16_bits(0x1806, 'Reference Time Update')
+GATT_NEXT_DST_CHANGE_SERVICE                = UUID.from_16_bits(0x1807, 'Next DST Change')
+GATT_GLUCOSE_SERVICE                        = UUID.from_16_bits(0x1808, 'Glucose')
+GATT_HEALTH_THERMOMETER_SERVICE             = UUID.from_16_bits(0x1809, 'Health Thermometer')
+GATT_DEVICE_INFORMATION_SERVICE             = UUID.from_16_bits(0x180A, 'Device Information')
+GATT_HEART_RATE_SERVICE                     = UUID.from_16_bits(0x180D, 'Heart Rate')
+GATT_PHONE_ALERT_STATUS_SERVICE             = UUID.from_16_bits(0x180E, 'Phone Alert Status')
+GATT_BATTERY_SERVICE                        = UUID.from_16_bits(0x180F, 'Battery')
+GATT_BLOOD_PRESSURE_SERVICE                 = UUID.from_16_bits(0x1810, 'Blood Pressure')
+GATT_ALERT_NOTIFICATION_SERVICE             = UUID.from_16_bits(0x1811, 'Alert Notification')
+GATT_HUMAN_INTERFACE_DEVICE_SERVICE         = UUID.from_16_bits(0x1812, 'Human Interface Device')
+GATT_SCAN_PARAMETERS_SERVICE                = UUID.from_16_bits(0x1813, 'Scan Parameters')
+GATT_RUNNING_SPEED_AND_CADENCE_SERVICE      = UUID.from_16_bits(0x1814, 'Running Speed and Cadence')
+GATT_AUTOMATION_IO_SERVICE                  = UUID.from_16_bits(0x1815, 'Automation IO')
+GATT_CYCLING_SPEED_AND_CADENCE_SERVICE      = UUID.from_16_bits(0x1816, 'Cycling Speed and Cadence')
+GATT_CYCLING_POWER_SERVICE                  = UUID.from_16_bits(0x1818, 'Cycling Power')
+GATT_LOCATION_AND_NAVIGATION_SERVICE        = UUID.from_16_bits(0x1819, 'Location and Navigation')
+GATT_ENVIRONMENTAL_SENSING_SERVICE          = UUID.from_16_bits(0x181A, 'Environmental Sensing')
+GATT_BODY_COMPOSITION_SERVICE               = UUID.from_16_bits(0x181B, 'Body Composition')
+GATT_USER_DATA_SERVICE                      = UUID.from_16_bits(0x181C, 'User Data')
+GATT_WEIGHT_SCALE_SERVICE                   = UUID.from_16_bits(0x181D, 'Weight Scale')
+GATT_BOND_MANAGEMENT_SERVICE                = UUID.from_16_bits(0x181E, 'Bond Management')
+GATT_CONTINUOUS_GLUCOSE_MONITORING_SERVICE  = UUID.from_16_bits(0x181F, 'Continuous Glucose Monitoring')
+GATT_INTERNET_PROTOCOL_SUPPORT_SERVICE      = UUID.from_16_bits(0x1820, 'Internet Protocol Support')
+GATT_INDOOR_POSITIONING_SERVICE             = UUID.from_16_bits(0x1821, 'Indoor Positioning')
+GATT_PULSE_OXIMETER_SERVICE                 = UUID.from_16_bits(0x1822, 'Pulse Oximeter')
+GATT_HTTP_PROXY_SERVICE                     = UUID.from_16_bits(0x1823, 'HTTP Proxy')
+GATT_TRANSPORT_DISCOVERY_SERVICE            = UUID.from_16_bits(0x1824, 'Transport Discovery')
+GATT_OBJECT_TRANSFER_SERVICE                = UUID.from_16_bits(0x1825, 'Object Transfer')
+GATT_FITNESS_MACHINE_SERVICE                = UUID.from_16_bits(0x1826, 'Fitness Machine')
+GATT_MESH_PROVISIONING_SERVICE              = UUID.from_16_bits(0x1827, 'Mesh Provisioning')
+GATT_MESH_PROXY_SERVICE                     = UUID.from_16_bits(0x1828, 'Mesh Proxy')
+GATT_RECONNECTION_CONFIGURATION_SERVICE     = UUID.from_16_bits(0x1829, 'Reconnection Configuration')
+GATT_INSULIN_DELIVERY_SERVICE               = UUID.from_16_bits(0x183A, 'Insulin Delivery')
+GATT_BINARY_SENSOR_SERVICE                  = UUID.from_16_bits(0x183B, 'Binary Sensor')
+GATT_EMERGENCY_CONFIGURATION_SERVICE        = UUID.from_16_bits(0x183C, 'Emergency Configuration')
+GATT_PHYSICAL_ACTIVITY_MONITOR_SERVICE      = UUID.from_16_bits(0x183E, 'Physical Activity Monitor')
+GATT_AUDIO_INPUT_CONTROL_SERVICE            = UUID.from_16_bits(0x1843, 'Audio Input Control')
+GATT_VOLUME_CONTROL_SERVICE                 = UUID.from_16_bits(0x1844, 'Volume Control')
+GATT_VOLUME_OFFSET_CONTROL_SERVICE          = UUID.from_16_bits(0x1845, 'Volume Offset Control')
+GATT_COORDINATED_SET_IDENTIFICATION_SERVICE = UUID.from_16_bits(0x1846, 'Coordinated Set Identification Service')
+GATT_DEVICE_TIME_SERVICE                    = UUID.from_16_bits(0x1847, 'Device Time')
+GATT_MEDIA_CONTROL_SERVICE                  = UUID.from_16_bits(0x1848, 'Media Control Service')
+GATT_GENERIC_MEDIA_CONTROL_SERVICE          = UUID.from_16_bits(0x1849, 'Generic Media Control Service')
+GATT_CONSTANT_TONE_EXTENSION_SERVICE        = UUID.from_16_bits(0x184A, 'Constant Tone Extension')
+GATT_TELEPHONE_BEARER_SERVICE               = UUID.from_16_bits(0x184B, 'Telephone Bearer Service')
+GATT_GENERIC_TELEPHONE_BEARER_SERVICE       = UUID.from_16_bits(0x184C, 'Generic Telephone Bearer Service')
+GATT_MICROPHONE_CONTROL_SERVICE             = UUID.from_16_bits(0x184D, 'Microphone Control')
+
+# Types
+GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE   = UUID.from_16_bits(0x2800, 'Primary Service')
+GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE = UUID.from_16_bits(0x2801, 'Secondary Service')
+GATT_INCLUDE_ATTRIBUTE_TYPE           = UUID.from_16_bits(0x2802, 'Include')
+GATT_CHARACTERISTIC_ATTRIBUTE_TYPE    = UUID.from_16_bits(0x2803, 'Characteristic')
+
+# Descriptors
+GATT_CHARACTERISTIC_EXTENDED_PROPERTIES_DESCRIPTOR   = UUID.from_16_bits(0x2900, 'Characteristic Extended Properties')
+GATT_CHARACTERISTIC_USER_DESCRIPTION_DESCRIPTOR      = UUID.from_16_bits(0x2901, 'Characteristic User Description')
+GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR  = UUID.from_16_bits(0x2902, 'Client Characteristic Configuration')
+GATT_SERVER_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR  = UUID.from_16_bits(0x2903, 'Server Characteristic Configuration')
+GATT_CHARACTERISTIC_PRESENTATION_FORMAT_DESCRIPTOR   = UUID.from_16_bits(0x2904, 'Characteristic Format')
+GATT_CHARACTERISTIC_AGGREGATE_FORMAT_DESCRIPTOR      = UUID.from_16_bits(0x2905, 'Characteristic Aggregate Format')
+GATT_VALID_RANGE_DESCRIPTOR                          = UUID.from_16_bits(0x2906, 'Valid Range')
+GATT_EXTERNAL_REPORT_DESCRIPTOR                      = UUID.from_16_bits(0x2907, 'External Report')
+GATT_REPORT_REFERENCE_DESCRIPTOR                     = UUID.from_16_bits(0x2908, 'Report Reference')
+GATT_NUMBER_OF_DIGITALS_DESCRIPTOR                   = UUID.from_16_bits(0x2909, 'Number of Digitals')
+GATT_VALUE_TRIGGER_SETTING_DESCRIPTOR                = UUID.from_16_bits(0x290A, 'Value Trigger Setting')
+GATT_ENVIRONMENTAL_SENSING_CONFIGURATION_DESCRIPTOR  = UUID.from_16_bits(0x290B, 'Environmental Sensing Configuration')
+GATT_ENVIRONMENTAL_SENSING_MEASUREMENT_DESCRIPTOR    = UUID.from_16_bits(0x290C, 'Environmental Sensing Measurement')
+GATT_ENVIRONMENTAL_SENSING_TRIGGER_DESCRIPTOR        = UUID.from_16_bits(0x290D, 'Environmental Sensing Trigger Setting')
+GATT_TIME_TRIGGER_DESCRIPTOR                         = UUID.from_16_bits(0x290E, 'Time Trigger Setting')
+GATT_COMPLETE_BR_EDR_TRANSPORT_BLOCK_DATA_DESCRIPTOR = UUID.from_16_bits(0x290F, 'Complete BR-EDR Transport Block Data')
+
+# Device Information Service
+GATT_SYSTEM_ID_CHARACTERISTIC                          = UUID.from_16_bits(0x2A23, 'System ID')
+GATT_MODEL_NUMBER_STRING_CHARACTERISTIC                = UUID.from_16_bits(0x2A24, 'Model Number String')
+GATT_SERIAL_NUMBER_STRING_CHARACTERISTIC               = UUID.from_16_bits(0x2A25, 'Serial Number String')
+GATT_FIRMWARE_REVISION_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A26, 'Firmware Revision String')
+GATT_HARDWARE_REVISION_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A27, 'Hardware Revision String')
+GATT_SOFTWARE_REVISION_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A28, 'Software Revision String')
+GATT_MANUFACTURER_NAME_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A29, 'Manufacturer Name String')
+GATT_REGULATORY_CERTIFICATION_DATA_LIST_CHARACTERISTIC = UUID.from_16_bits(0x2A2A, 'IEEE 11073-20601 Regulatory Certification Data List')
+GATT_PNP_ID_CHARACTERISTIC                             = UUID.from_16_bits(0x2A50, 'PnP ID')
+
+# Human Interface Device Service
+GATT_HID_INFORMATION_CHARACTERISTIC   = UUID.from_16_bits(0x2A4A, 'HID Information')
+GATT_REPORT_MAP_CHARACTERISTIC        = UUID.from_16_bits(0x2A4B, 'Report Map')
+GATT_HID_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2A4C, 'HID Control Point')
+GATT_REPORT_CHARACTERISTIC            = UUID.from_16_bits(0x2A4D, 'Report')
+GATT_PROTOCOL_MODE_CHARACTERISTIC     = UUID.from_16_bits(0x2A4E, 'Protocol Mode')
+
+# Heart Rate Service
+GATT_HEART_RATE_MEASUREMENT_CHARACTERISTIC   = UUID.from_16_bits(0x2A37, 'Heart Rate Measurement')
+GATT_BODY_SENSOR_LOCATION_CHARACTERISTIC     = UUID.from_16_bits(0x2A38, 'Body Sensor Location')
+GATT_HEART_RATE_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2A39, 'Heart Rate Control Point')
+
+# Battery Service
+GATT_BATTERY_LEVEL_CHARACTERISTIC = UUID.from_16_bits(0x2A19, 'Battery Level')
+
+# ASHA Service
+GATT_ASHA_SERVICE                             = UUID.from_16_bits(0xFDF0, 'Audio Streaming for Hearing Aid')
+GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC = UUID('6333651e-c481-4a3e-9169-7c902aad37bb', 'ReadOnlyProperties')
+GATT_ASHA_AUDIO_CONTROL_POINT_CHARACTERISTIC  = UUID('f0d4de7e-4a88-476c-9d9f-1937b0996cc0', 'AudioControlPoint')
+GATT_ASHA_AUDIO_STATUS_CHARACTERISTIC         = UUID('38663f1a-e711-4cac-b641-326b56404837', 'AudioStatus')
+GATT_ASHA_VOLUME_CHARACTERISTIC               = UUID('00e4ca9e-ab14-41e4-8823-f9e70c7e91df', 'Volume')
+GATT_ASHA_LE_PSM_OUT_CHARACTERISTIC           = UUID('2d410339-82b6-42aa-b34e-e2e01df8cc1a', 'LE_PSM_OUT')
+
+# Misc
+GATT_DEVICE_NAME_CHARACTERISTIC                                = UUID.from_16_bits(0x2A00, 'Device Name')
+GATT_APPEARANCE_CHARACTERISTIC                                 = UUID.from_16_bits(0x2A01, 'Appearance')
+GATT_PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC                    = UUID.from_16_bits(0x2A02, 'Peripheral Privacy Flag')
+GATT_RECONNECTION_ADDRESS_CHARACTERISTIC                       = UUID.from_16_bits(0x2A03, 'Reconnection Address')
+GATT_PERIPHERAL_PREFERRED_CONNECTION_PARAMETERS_CHARACTERISTIC = UUID.from_16_bits(0x2A04, 'Peripheral Preferred Connection Parameters')
+GATT_SERVICE_CHANGED_CHARACTERISTIC                            = UUID.from_16_bits(0x2A05, 'Service Changed')
+GATT_ALERT_LEVEL_CHARACTERISTIC                                = UUID.from_16_bits(0x2A06, 'Alert Level')
+GATT_TX_POWER_LEVEL_CHARACTERISTIC                             = UUID.from_16_bits(0x2A07, 'Tx Power Level')
+GATT_BOOT_KEYBOARD_INPUT_REPORT_CHARACTERISTIC                 = UUID.from_16_bits(0x2A22, 'Boot Keyboard Input Report')
+GATT_CURRENT_TIME_CHARACTERISTIC                               = UUID.from_16_bits(0x2A2B, 'Current Time')
+GATT_BOOT_KEYBOARD_OUTPUT_REPORT_CHARACTERISTIC                = UUID.from_16_bits(0x2A32, 'Boot Keyboard Output Report')
+GATT_CENTRAL_ADDRESS_RESOLUTION__CHARACTERISTIC                = UUID.from_16_bits(0x2AA6, 'Central Address Resolution')
+
+# fmt: on
+# pylint: enable=line-too-long
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+
+
+def show_services(services):
+    for service in services:
+        print(color(str(service), 'cyan'))
+
+        for characteristic in service.characteristics:
+            print(color('  ' + str(characteristic), 'magenta'))
+
+            for descriptor in characteristic.descriptors:
+                print(color('    ' + str(descriptor), 'green'))
+
+
+# -----------------------------------------------------------------------------
+class Service(Attribute):
+    '''
+    See Vol 3, Part G - 3.1 SERVICE DEFINITION
+    '''
+
+    def __init__(self, uuid, characteristics: list[Characteristic], primary=True):
+        # Convert the uuid to a UUID object if it isn't already
+        if isinstance(uuid, str):
+            uuid = UUID(uuid)
+
+        super().__init__(
+            GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
+            if primary
+            else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
+            Attribute.READABLE,
+            uuid.to_pdu_bytes(),
+        )
+        self.uuid = uuid
+        self.included_services = []
+        self.characteristics = characteristics[:]
+        self.primary = primary
+
+    def get_advertising_data(self):
+        """
+        Get Service specific advertising data
+        Defined by each Service, default value is empty
+        :return Service data for advertising
+        """
+        return None
+
+    def __str__(self):
+        return (
+            f'Service(handle=0x{self.handle:04X}, '
+            f'end=0x{self.end_group_handle:04X}, '
+            f'uuid={self.uuid})'
+            f'{"" if self.primary else "*"}'
+        )
+
+
+# -----------------------------------------------------------------------------
+class TemplateService(Service):
+    '''
+    Convenience abstract class that can be used by profile-specific subclasses that want
+    to expose their UUID as a class property
+    '''
+
+    UUID = None
+
+    def __init__(self, characteristics, primary=True):
+        super().__init__(self.UUID, characteristics, primary)
+
+
+# -----------------------------------------------------------------------------
+class Characteristic(Attribute):
+    '''
+    See Vol 3, Part G - 3.3 CHARACTERISTIC DEFINITION
+    '''
+
+    # Property flags
+    BROADCAST = 0x01
+    READ = 0x02
+    WRITE_WITHOUT_RESPONSE = 0x04
+    WRITE = 0x08
+    NOTIFY = 0x10
+    INDICATE = 0x20
+    AUTHENTICATED_SIGNED_WRITES = 0x40
+    EXTENDED_PROPERTIES = 0x80
+
+    PROPERTY_NAMES = {
+        BROADCAST: 'BROADCAST',
+        READ: 'READ',
+        WRITE_WITHOUT_RESPONSE: 'WRITE_WITHOUT_RESPONSE',
+        WRITE: 'WRITE',
+        NOTIFY: 'NOTIFY',
+        INDICATE: 'INDICATE',
+        AUTHENTICATED_SIGNED_WRITES: 'AUTHENTICATED_SIGNED_WRITES',
+        EXTENDED_PROPERTIES: 'EXTENDED_PROPERTIES',
+    }
+
+    @staticmethod
+    def property_name(property_int):
+        return Characteristic.PROPERTY_NAMES.get(property_int, '')
+
+    @staticmethod
+    def properties_as_string(properties):
+        return ','.join(
+            [
+                Characteristic.property_name(p)
+                for p in Characteristic.PROPERTY_NAMES
+                if properties & p
+            ]
+        )
+
+    @staticmethod
+    def string_to_properties(properties_str: str):
+        return functools.reduce(
+            lambda x, y: x | get_dict_key_by_value(Characteristic.PROPERTY_NAMES, y),
+            properties_str.split(","),
+            0,
+        )
+
+    def __init__(
+        self,
+        uuid,
+        properties,
+        permissions,
+        value=b'',
+        descriptors: Sequence[Descriptor] = (),
+    ):
+        super().__init__(uuid, permissions, value)
+        self.uuid = self.type
+        if isinstance(properties, str):
+            self.properties = Characteristic.string_to_properties(properties)
+        else:
+            self.properties = properties
+        self.descriptors = descriptors
+
+    def get_descriptor(self, descriptor_type):
+        for descriptor in self.descriptors:
+            if descriptor.type == descriptor_type:
+                return descriptor
+
+        return None
+
+    def __str__(self):
+        return (
+            f'Characteristic(handle=0x{self.handle:04X}, '
+            f'end=0x{self.end_group_handle:04X}, '
+            f'uuid={self.uuid}, '
+            f'properties={Characteristic.properties_as_string(self.properties)})'
+        )
+
+
+# -----------------------------------------------------------------------------
+class CharacteristicDeclaration(Attribute):
+    '''
+    See Vol 3, Part G - 3.3.1 CHARACTERISTIC DECLARATION
+    '''
+
+    def __init__(self, characteristic, value_handle):
+        declaration_bytes = (
+            struct.pack('<BH', characteristic.properties, value_handle)
+            + characteristic.uuid.to_pdu_bytes()
+        )
+        super().__init__(
+            GATT_CHARACTERISTIC_ATTRIBUTE_TYPE, Attribute.READABLE, declaration_bytes
+        )
+        self.value_handle = value_handle
+        self.characteristic = characteristic
+
+    def __str__(self):
+        return (
+            f'CharacteristicDeclaration(handle=0x{self.handle:04X}, '
+            f'value_handle=0x{self.value_handle:04X}, '
+            f'uuid={self.characteristic.uuid}, properties='
+            f'{Characteristic.properties_as_string(self.characteristic.properties)})'
+        )
+
+
+# -----------------------------------------------------------------------------
+class CharacteristicValue:
+    '''
+    Characteristic value where reading and/or writing is delegated to functions
+    passed as arguments to the constructor.
+    '''
+
+    def __init__(self, read=None, write=None):
+        self._read = read
+        self._write = write
+
+    def read(self, connection):
+        return self._read(connection) if self._read else b''
+
+    def write(self, connection, value):
+        if self._write:
+            self._write(connection, value)
+
+
+# -----------------------------------------------------------------------------
+class CharacteristicAdapter:
+    '''
+    An adapter that can adapt any object with `read_value` and `write_value`
+    methods (like Characteristic and CharacteristicProxy objects) by wrapping
+    those methods with ones that return/accept encoded/decoded values.
+    Objects with async methods are considered proxies, so the adaptation is one
+    where the return value of `read_value` is decoded and the value passed to
+    `write_value` is encoded. Other objects are considered local characteristics
+    so the adaptation is one where the return value of `read_value` is encoded
+    and the value passed to `write_value` is decoded.
+    If the characteristic has a `subscribe` method, it is wrapped with one where
+    the values are decoded before being passed to the subscriber.
+    '''
+
+    def __init__(self, characteristic):
+        self.wrapped_characteristic = characteristic
+        self.subscribers = {}  # Map from subscriber to proxy subscriber
+
+        if asyncio.iscoroutinefunction(
+            characteristic.read_value
+        ) and asyncio.iscoroutinefunction(characteristic.write_value):
+            self.read_value = self.read_decoded_value
+            self.write_value = self.write_decoded_value
+        else:
+            self.read_value = self.read_encoded_value
+            self.write_value = self.write_encoded_value
+
+        if hasattr(self.wrapped_characteristic, 'subscribe'):
+            self.subscribe = self.wrapped_subscribe
+
+        if hasattr(self.wrapped_characteristic, 'unsubscribe'):
+            self.unsubscribe = self.wrapped_unsubscribe
+
+    def __getattr__(self, name):
+        return getattr(self.wrapped_characteristic, name)
+
+    def __setattr__(self, name, value):
+        if name in (
+            'wrapped_characteristic',
+            'subscribers',
+            'read_value',
+            'write_value',
+            'subscribe',
+            'unsubscribe',
+        ):
+            super().__setattr__(name, value)
+        else:
+            setattr(self.wrapped_characteristic, name, value)
+
+    def read_encoded_value(self, connection):
+        return self.encode_value(self.wrapped_characteristic.read_value(connection))
+
+    def write_encoded_value(self, connection, value):
+        return self.wrapped_characteristic.write_value(
+            connection, self.decode_value(value)
+        )
+
+    async def read_decoded_value(self):
+        return self.decode_value(await self.wrapped_characteristic.read_value())
+
+    async def write_decoded_value(self, value, with_response=False):
+        return await self.wrapped_characteristic.write_value(
+            self.encode_value(value), with_response
+        )
+
+    def encode_value(self, value):
+        return value
+
+    def decode_value(self, value):
+        return value
+
+    def wrapped_subscribe(self, subscriber=None):
+        if subscriber is not None:
+            if subscriber in self.subscribers:
+                # We already have a proxy subscriber
+                subscriber = self.subscribers[subscriber]
+            else:
+                # Create and register a proxy that will decode the value
+                original_subscriber = subscriber
+
+                def on_change(value):
+                    original_subscriber(self.decode_value(value))
+
+                self.subscribers[subscriber] = on_change
+                subscriber = on_change
+
+        return self.wrapped_characteristic.subscribe(subscriber)
+
+    def wrapped_unsubscribe(self, subscriber=None):
+        if subscriber in self.subscribers:
+            subscriber = self.subscribers.pop(subscriber)
+
+        return self.wrapped_characteristic.unsubscribe(subscriber)
+
+    def __str__(self):
+        wrapped = str(self.wrapped_characteristic)
+        return f'{self.__class__.__name__}({wrapped})'
+
+
+# -----------------------------------------------------------------------------
+class DelegatedCharacteristicAdapter(CharacteristicAdapter):
+    '''
+    Adapter that converts bytes values using an encode and a decode function.
+    '''
+
+    def __init__(self, characteristic, encode=None, decode=None):
+        super().__init__(characteristic)
+        self.encode = encode
+        self.decode = decode
+
+    def encode_value(self, value):
+        return self.encode(value) if self.encode else value
+
+    def decode_value(self, value):
+        return self.decode(value) if self.decode else value
+
+
+# -----------------------------------------------------------------------------
+class PackedCharacteristicAdapter(CharacteristicAdapter):
+    '''
+    Adapter that packs/unpacks characteristic values according to a standard
+    Python `struct` format.
+    For formats with a single value, the adapted `read_value` and `write_value`
+    methods return/accept single values. For formats with multiple values,
+    they return/accept a tuple with the same number of elements as is required for
+    the format.
+    '''
+
+    def __init__(self, characteristic, pack_format):
+        super().__init__(characteristic)
+        self.struct = struct.Struct(pack_format)
+
+    def pack(self, *values):
+        return self.struct.pack(*values)
+
+    def unpack(self, buffer):
+        return self.struct.unpack(buffer)
+
+    def encode_value(self, value):
+        return self.pack(*value if isinstance(value, tuple) else (value,))
+
+    def decode_value(self, value):
+        unpacked = self.unpack(value)
+        return unpacked[0] if len(unpacked) == 1 else unpacked
+
+
+# -----------------------------------------------------------------------------
+class MappedCharacteristicAdapter(PackedCharacteristicAdapter):
+    '''
+    Adapter that packs/unpacks characteristic values according to a standard
+    Python `struct` format.
+    The adapted `read_value` and `write_value` methods return/accept aa dictionary which
+    is packed/unpacked according to format, with the arguments extracted from the
+    dictionary by key, in the same order as they occur in the `keys` parameter.
+    '''
+
+    def __init__(self, characteristic, pack_format, keys):
+        super().__init__(characteristic, pack_format)
+        self.keys = keys
+
+    # pylint: disable=arguments-differ
+    def pack(self, values):
+        return super().pack(*(values[key] for key in self.keys))
+
+    def unpack(self, buffer):
+        return dict(zip(self.keys, super().unpack(buffer)))
+
+
+# -----------------------------------------------------------------------------
+class UTF8CharacteristicAdapter(CharacteristicAdapter):
+    '''
+    Adapter that converts strings to/from bytes using UTF-8 encoding
+    '''
+
+    def encode_value(self, value):
+        return value.encode('utf-8')
+
+    def decode_value(self, value):
+        return value.decode('utf-8')
+
+
+# -----------------------------------------------------------------------------
+class Descriptor(Attribute):
+    '''
+    See Vol 3, Part G - 3.3.3 Characteristic Descriptor Declarations
+    '''
+
+    def __str__(self):
+        return (
+            f'Descriptor(handle=0x{self.handle:04X}, '
+            f'type={self.type}, '
+            f'value={self.read_value(None).hex()})'
+        )
+
+
+class ClientCharacteristicConfigurationBits(enum.IntFlag):
+    '''
+    See Vol 3, Part G - 3.3.3.3 - Table 3.11 Client Characteristic Configuration bit
+    field definition
+    '''
+
+    DEFAULT = 0x0000
+    NOTIFICATION = 0x0001
+    INDICATION = 0x0002

bumble/gatt_client.py

@@ -0,0 +1,933 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# GATT - Generic Attribute Profile
+# Client
+#
+# See Bluetooth spec @ Vol 3, Part G
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+import struct
+
+from colors import color
+from pyee import EventEmitter
+
+from .hci import HCI_Constant
+from .att import (
+    ATT_ATTRIBUTE_NOT_FOUND_ERROR,
+    ATT_ATTRIBUTE_NOT_LONG_ERROR,
+    ATT_CID,
+    ATT_DEFAULT_MTU,
+    ATT_ERROR_RESPONSE,
+    ATT_INVALID_OFFSET_ERROR,
+    ATT_PDU,
+    ATT_RESPONSES,
+    ATT_Exchange_MTU_Request,
+    ATT_Find_By_Type_Value_Request,
+    ATT_Find_Information_Request,
+    ATT_Handle_Value_Confirmation,
+    ATT_Read_Blob_Request,
+    ATT_Read_By_Group_Type_Request,
+    ATT_Read_By_Type_Request,
+    ATT_Read_Request,
+    ATT_Write_Command,
+    ATT_Write_Request,
+)
+from . import core
+from .core import UUID, InvalidStateError, ProtocolError
+from .gatt import (
+    GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
+    GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
+    GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
+    GATT_REQUEST_TIMEOUT,
+    GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
+    Characteristic,
+    ClientCharacteristicConfigurationBits,
+)
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Proxies
+# -----------------------------------------------------------------------------
+class AttributeProxy(EventEmitter):
+    def __init__(self, client, handle, end_group_handle, attribute_type):
+        EventEmitter.__init__(self)
+        self.client = client
+        self.handle = handle
+        self.end_group_handle = end_group_handle
+        self.type = attribute_type
+
+    async def read_value(self, no_long_read=False):
+        return self.decode_value(
+            await self.client.read_value(self.handle, no_long_read)
+        )
+
+    async def write_value(self, value, with_response=False):
+        return await self.client.write_value(
+            self.handle, self.encode_value(value), with_response
+        )
+
+    def encode_value(self, value):
+        return value
+
+    def decode_value(self, value_bytes):
+        return value_bytes
+
+    def __str__(self):
+        return f'Attribute(handle=0x{self.handle:04X}, type={self.type})'
+
+
+class ServiceProxy(AttributeProxy):
+    @staticmethod
+    def from_client(service_class, client, service_uuid):
+        # The service and its characteristics are considered to have already been
+        # discovered
+        services = client.get_services_by_uuid(service_uuid)
+        service = services[0] if services else None
+        return service_class(service) if service else None
+
+    def __init__(self, client, handle, end_group_handle, uuid, primary=True):
+        attribute_type = (
+            GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
+            if primary
+            else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE
+        )
+        super().__init__(client, handle, end_group_handle, attribute_type)
+        self.uuid = uuid
+        self.characteristics = []
+
+    async def discover_characteristics(self, uuids=()):
+        return await self.client.discover_characteristics(uuids, self)
+
+    def get_characteristics_by_uuid(self, uuid):
+        return self.client.get_characteristics_by_uuid(uuid, self)
+
+    def __str__(self):
+        return f'Service(handle=0x{self.handle:04X}, uuid={self.uuid})'
+
+
+class CharacteristicProxy(AttributeProxy):
+    def __init__(self, client, handle, end_group_handle, uuid, properties):
+        super().__init__(client, handle, end_group_handle, uuid)
+        self.uuid = uuid
+        self.properties = properties
+        self.descriptors = []
+        self.descriptors_discovered = False
+        self.subscribers = {}  # Map from subscriber to proxy subscriber
+
+    def get_descriptor(self, descriptor_type):
+        for descriptor in self.descriptors:
+            if descriptor.type == descriptor_type:
+                return descriptor
+
+        return None
+
+    async def discover_descriptors(self):
+        return await self.client.discover_descriptors(self)
+
+    async def subscribe(self, subscriber=None, prefer_notify=True):
+        if subscriber is not None:
+            if subscriber in self.subscribers:
+                # We already have a proxy subscriber
+                subscriber = self.subscribers[subscriber]
+            else:
+                # Create and register a proxy that will decode the value
+                original_subscriber = subscriber
+
+                def on_change(value):
+                    original_subscriber(self.decode_value(value))
+
+                self.subscribers[subscriber] = on_change
+                subscriber = on_change
+
+        return await self.client.subscribe(self, subscriber, prefer_notify)
+
+    async def unsubscribe(self, subscriber=None):
+        if subscriber in self.subscribers:
+            subscriber = self.subscribers.pop(subscriber)
+
+        return await self.client.unsubscribe(self, subscriber)
+
+    def __str__(self):
+        return (
+            f'Characteristic(handle=0x{self.handle:04X}, '
+            f'uuid={self.uuid}, '
+            f'properties={Characteristic.properties_as_string(self.properties)})'
+        )
+
+
+class DescriptorProxy(AttributeProxy):
+    def __init__(self, client, handle, descriptor_type):
+        super().__init__(client, handle, 0, descriptor_type)
+
+    def __str__(self):
+        return f'Descriptor(handle=0x{self.handle:04X}, type={self.type})'
+
+
+class ProfileServiceProxy:
+    '''
+    Base class for profile-specific service proxies
+    '''
+
+    @classmethod
+    def from_client(cls, client):
+        return ServiceProxy.from_client(cls, client, cls.SERVICE_CLASS.UUID)
+
+
+# -----------------------------------------------------------------------------
+# GATT Client
+# -----------------------------------------------------------------------------
+class Client:
+    def __init__(self, connection):
+        self.connection = connection
+        self.mtu_exchange_done = False
+        self.request_semaphore = asyncio.Semaphore(1)
+        self.pending_request = None
+        self.pending_response = None
+        self.notification_subscribers = (
+            {}
+        )  # Notification subscribers, by attribute handle
+        self.indication_subscribers = {}  # Indication subscribers, by attribute handle
+        self.services = []
+
+    def send_gatt_pdu(self, pdu):
+        self.connection.send_l2cap_pdu(ATT_CID, pdu)
+
+    async def send_command(self, command):
+        logger.debug(
+            f'GATT Command from client: [0x{self.connection.handle:04X}] {command}'
+        )
+        self.send_gatt_pdu(command.to_bytes())
+
+    async def send_request(self, request):
+        logger.debug(
+            f'GATT Request from client: [0x{self.connection.handle:04X}] {request}'
+        )
+
+        # Wait until we can send (only one pending command at a time for the connection)
+        response = None
+        async with self.request_semaphore:
+            assert self.pending_request is None
+            assert self.pending_response is None
+
+            # Create a future value to hold the eventual response
+            self.pending_response = asyncio.get_running_loop().create_future()
+            self.pending_request = request
+
+            try:
+                self.send_gatt_pdu(request.to_bytes())
+                response = await asyncio.wait_for(
+                    self.pending_response, GATT_REQUEST_TIMEOUT
+                )
+            except asyncio.TimeoutError as error:
+                logger.warning(color('!!! GATT Request timeout', 'red'))
+                raise core.TimeoutError(f'GATT timeout for {request.name}') from error
+            finally:
+                self.pending_request = None
+                self.pending_response = None
+
+        return response
+
+    def send_confirmation(self, confirmation):
+        logger.debug(
+            f'GATT Confirmation from client: [0x{self.connection.handle:04X}] '
+            f'{confirmation}'
+        )
+        self.send_gatt_pdu(confirmation.to_bytes())
+
+    async def request_mtu(self, mtu):
+        # Check the range
+        if mtu < ATT_DEFAULT_MTU:
+            raise ValueError(f'MTU must be >= {ATT_DEFAULT_MTU}')
+        if mtu > 0xFFFF:
+            raise ValueError('MTU must be <= 0xFFFF')
+
+        # We can only send one request per connection
+        if self.mtu_exchange_done:
+            return self.connection.att_mtu
+
+        # Send the request
+        self.mtu_exchange_done = True
+        response = await self.send_request(ATT_Exchange_MTU_Request(client_rx_mtu=mtu))
+        if response.op_code == ATT_ERROR_RESPONSE:
+            raise ProtocolError(
+                response.error_code,
+                'att',
+                ATT_PDU.error_name(response.error_code),
+                response,
+            )
+
+        # Compute the final MTU
+        self.connection.att_mtu = min(mtu, response.server_rx_mtu)
+
+        return self.connection.att_mtu
+
+    def get_services_by_uuid(self, uuid):
+        return [service for service in self.services if service.uuid == uuid]
+
+    def get_characteristics_by_uuid(self, uuid, service=None):
+        services = [service] if service else self.services
+        return [
+            c
+            for c in [c for s in services for c in s.characteristics]
+            if c.uuid == uuid
+        ]
+
+    def on_service_discovered(self, service):
+        '''Add a service to the service list if it wasn't already there'''
+        already_known = False
+        for existing_service in self.services:
+            if existing_service.handle == service.handle:
+                already_known = True
+                break
+        if not already_known:
+            self.services.append(service)
+
+    async def discover_services(self, uuids=None):
+        '''
+        See Vol 3, Part G - 4.4.1 Discover All Primary Services
+        '''
+        starting_handle = 0x0001
+        services = []
+        while starting_handle < 0xFFFF:
+            response = await self.send_request(
+                ATT_Read_By_Group_Type_Request(
+                    starting_handle=starting_handle,
+                    ending_handle=0xFFFF,
+                    attribute_group_type=GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(
+                        '!!! unexpected error while discovering services: '
+                        f'{HCI_Constant.error_name(response.error_code)}'
+                    )
+                    # TODO raise appropriate exception
+                    return
+                break
+
+            for (
+                attribute_handle,
+                end_group_handle,
+                attribute_value,
+            ) in response.attributes:
+                if (
+                    attribute_handle < starting_handle
+                    or end_group_handle < attribute_handle
+                ):
+                    # Something's not right
+                    logger.warning(
+                        f'bogus handle values: {attribute_handle} {end_group_handle}'
+                    )
+                    return
+
+                # Create a service proxy for this service
+                service = ServiceProxy(
+                    self,
+                    attribute_handle,
+                    end_group_handle,
+                    UUID.from_bytes(attribute_value),
+                    True,
+                )
+
+                # Filter out returned services based on the given uuids list
+                if (not uuids) or (service.uuid in uuids):
+                    services.append(service)
+
+                # Add the service to the peer's service list
+                self.on_service_discovered(service)
+
+            # Stop if for some reason the list was empty
+            if not response.attributes:
+                break
+
+            # Move on to the next chunk
+            starting_handle = response.attributes[-1][1] + 1
+
+        return services
+
+    async def discover_service(self, uuid):
+        '''
+        See Vol 3, Part G - 4.4.2 Discover Primary Service by Service UUID
+        '''
+
+        # Force uuid to be a UUID object
+        if isinstance(uuid, str):
+            uuid = UUID(uuid)
+
+        starting_handle = 0x0001
+        services = []
+        while starting_handle < 0xFFFF:
+            response = await self.send_request(
+                ATT_Find_By_Type_Value_Request(
+                    starting_handle=starting_handle,
+                    ending_handle=0xFFFF,
+                    attribute_type=GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
+                    attribute_value=uuid.to_pdu_bytes(),
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(
+                        '!!! unexpected error while discovering services: '
+                        f'{HCI_Constant.error_name(response.error_code)}'
+                    )
+                    # TODO raise appropriate exception
+                    return
+                break
+
+            for attribute_handle, end_group_handle in response.handles_information:
+                if (
+                    attribute_handle < starting_handle
+                    or end_group_handle < attribute_handle
+                ):
+                    # Something's not right
+                    logger.warning(
+                        f'bogus handle values: {attribute_handle} {end_group_handle}'
+                    )
+                    return
+
+                # Create a service proxy for this service
+                service = ServiceProxy(
+                    self, attribute_handle, end_group_handle, uuid, True
+                )
+
+                # Add the service to the peer's service list
+                services.append(service)
+                self.on_service_discovered(service)
+
+                # Check if we've reached the end already
+                if end_group_handle == 0xFFFF:
+                    break
+
+            # Stop if for some reason the list was empty
+            if not response.handles_information:
+                break
+
+            # Move on to the next chunk
+            starting_handle = response.handles_information[-1][1] + 1
+
+        return services
+
+    async def discover_included_services(self, _service):
+        '''
+        See Vol 3, Part G - 4.5.1 Find Included Services
+        '''
+        # TODO
+        return []
+
+    async def discover_characteristics(self, uuids, service):
+        '''
+        See Vol 3, Part G - 4.6.1 Discover All Characteristics of a Service and 4.6.2
+        Discover Characteristics by UUID
+        '''
+
+        # Cast the UUIDs type from string to object if needed
+        uuids = [UUID(uuid) if isinstance(uuid, str) else uuid for uuid in uuids]
+
+        # Decide which services to discover for
+        services = [service] if service else self.services
+
+        # Perform characteristic discovery for each service
+        discovered_characteristics = []
+        for service in services:
+            starting_handle = service.handle
+            ending_handle = service.end_group_handle
+
+            characteristics = []
+            while starting_handle <= ending_handle:
+                response = await self.send_request(
+                    ATT_Read_By_Type_Request(
+                        starting_handle=starting_handle,
+                        ending_handle=ending_handle,
+                        attribute_type=GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
+                    )
+                )
+                if response is None:
+                    # TODO raise appropriate exception
+                    return []
+
+                # Check if we reached the end of the iteration
+                if response.op_code == ATT_ERROR_RESPONSE:
+                    if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                        # Unexpected end
+                        logger.warning(
+                            '!!! unexpected error while discovering characteristics: '
+                            f'{HCI_Constant.error_name(response.error_code)}'
+                        )
+                        # TODO raise appropriate exception
+                        return
+                    break
+
+                # Stop if for some reason the list was empty
+                if not response.attributes:
+                    break
+
+                # Process all characteristics returned in this iteration
+                for attribute_handle, attribute_value in response.attributes:
+                    if attribute_handle < starting_handle:
+                        # Something's not right
+                        logger.warning(f'bogus handle value: {attribute_handle}')
+                        return []
+
+                    properties, handle = struct.unpack_from('<BH', attribute_value)
+                    characteristic_uuid = UUID.from_bytes(attribute_value[3:])
+                    characteristic = CharacteristicProxy(
+                        self, handle, 0, characteristic_uuid, properties
+                    )
+
+                    # Set the previous characteristic's end handle
+                    if characteristics:
+                        characteristics[-1].end_group_handle = attribute_handle - 1
+
+                    characteristics.append(characteristic)
+
+                # Move on to the next characteristics
+                starting_handle = response.attributes[-1][0] + 1
+
+            # Set the end handle for the last characteristic
+            if characteristics:
+                characteristics[-1].end_group_handle = service.end_group_handle
+
+            # Set the service's characteristics
+            characteristics = [
+                c for c in characteristics if not uuids or c.uuid in uuids
+            ]
+            service.characteristics = characteristics
+            discovered_characteristics.extend(characteristics)
+
+        return discovered_characteristics
+
+    async def discover_descriptors(
+        self, characteristic=None, start_handle=None, end_handle=None
+    ):
+        '''
+        See Vol 3, Part G - 4.7.1 Discover All Characteristic Descriptors
+        '''
+        if characteristic:
+            starting_handle = characteristic.handle + 1
+            ending_handle = characteristic.end_group_handle
+        elif start_handle and end_handle:
+            starting_handle = start_handle
+            ending_handle = end_handle
+        else:
+            return []
+
+        descriptors = []
+        while starting_handle <= ending_handle:
+            response = await self.send_request(
+                ATT_Find_Information_Request(
+                    starting_handle=starting_handle, ending_handle=ending_handle
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(
+                        '!!! unexpected error while discovering descriptors: '
+                        f'{HCI_Constant.error_name(response.error_code)}'
+                    )
+                    # TODO raise appropriate exception
+                    return []
+                break
+
+            # Stop if for some reason the list was empty
+            if not response.information:
+                break
+
+            # Process all descriptors returned in this iteration
+            for attribute_handle, attribute_uuid in response.information:
+                if attribute_handle < starting_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle value: {attribute_handle}')
+                    return []
+
+                descriptor = DescriptorProxy(
+                    self, attribute_handle, UUID.from_bytes(attribute_uuid)
+                )
+                descriptors.append(descriptor)
+                # TODO: read descriptor value
+
+            # Move on to the next descriptor
+            starting_handle = response.information[-1][0] + 1
+
+        # Set the characteristic's descriptors
+        if characteristic:
+            characteristic.descriptors = descriptors
+
+        return descriptors
+
+    async def discover_attributes(self):
+        '''
+        Discover all attributes, regardless of type
+        '''
+        starting_handle = 0x0001
+        ending_handle = 0xFFFF
+        attributes = []
+        while True:
+            response = await self.send_request(
+                ATT_Find_Information_Request(
+                    starting_handle=starting_handle, ending_handle=ending_handle
+                )
+            )
+            if response is None:
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(
+                        '!!! unexpected error while discovering attributes: '
+                        f'{HCI_Constant.error_name(response.error_code)}'
+                    )
+                    return []
+                break
+
+            for attribute_handle, attribute_uuid in response.information:
+                if attribute_handle < starting_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle value: {attribute_handle}')
+                    return []
+
+                attribute = AttributeProxy(
+                    self, attribute_handle, 0, UUID.from_bytes(attribute_uuid)
+                )
+                attributes.append(attribute)
+
+            # Move on to the next attributes
+            starting_handle = attributes[-1].handle + 1
+
+        return attributes
+
+    async def subscribe(self, characteristic, subscriber=None, prefer_notify=True):
+        # If we haven't already discovered the descriptors for this characteristic,
+        # do it now
+        if not characteristic.descriptors_discovered:
+            await self.discover_descriptors(characteristic)
+
+        # Look for the CCCD descriptor
+        cccd = characteristic.get_descriptor(
+            GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR
+        )
+        if not cccd:
+            logger.warning('subscribing to characteristic with no CCCD descriptor')
+            return
+
+        if (
+            characteristic.properties & Characteristic.NOTIFY
+            and characteristic.properties & Characteristic.INDICATE
+        ):
+            if prefer_notify:
+                bits = ClientCharacteristicConfigurationBits.NOTIFICATION
+                subscribers = self.notification_subscribers
+            else:
+                bits = ClientCharacteristicConfigurationBits.INDICATION
+                subscribers = self.indication_subscribers
+        elif characteristic.properties & Characteristic.NOTIFY:
+            bits = ClientCharacteristicConfigurationBits.NOTIFICATION
+            subscribers = self.notification_subscribers
+        elif characteristic.properties & Characteristic.INDICATE:
+            bits = ClientCharacteristicConfigurationBits.INDICATION
+            subscribers = self.indication_subscribers
+        else:
+            raise InvalidStateError("characteristic is not notify or indicate")
+
+        # Add subscribers to the sets
+        subscriber_set = subscribers.setdefault(characteristic.handle, set())
+        if subscriber is not None:
+            subscriber_set.add(subscriber)
+        # Add the characteristic as a subscriber, which will result in the
+        # characteristic emitting an 'update' event when a notification or indication
+        # is received
+        subscriber_set.add(characteristic)
+
+        await self.write_value(cccd, struct.pack('<H', bits), with_response=True)
+
+    async def unsubscribe(self, characteristic, subscriber=None):
+        # If we haven't already discovered the descriptors for this characteristic,
+        # do it now
+        if not characteristic.descriptors_discovered:
+            await self.discover_descriptors(characteristic)
+
+        # Look for the CCCD descriptor
+        cccd = characteristic.get_descriptor(
+            GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR
+        )
+        if not cccd:
+            logger.warning('unsubscribing from characteristic with no CCCD descriptor')
+            return
+
+        if subscriber is not None:
+            # Remove matching subscriber from subscriber sets
+            for subscriber_set in (
+                self.notification_subscribers,
+                self.indication_subscribers,
+            ):
+                subscribers = subscriber_set.get(characteristic.handle, [])
+                if subscriber in subscribers:
+                    subscribers.remove(subscriber)
+
+                    # Cleanup if we removed the last one
+                    if not subscribers:
+                        del subscriber_set[characteristic.handle]
+        else:
+            # Remove all subscribers for this attribute from the sets!
+            self.notification_subscribers.pop(characteristic.handle, None)
+            self.indication_subscribers.pop(characteristic.handle, None)
+
+        if not self.notification_subscribers and not self.indication_subscribers:
+            # No more subscribers left
+            await self.write_value(cccd, b'\x00\x00', with_response=True)
+
+    async def read_value(self, attribute, no_long_read=False):
+        '''
+        See Vol 3, Part G - 4.8.1 Read Characteristic Value
+
+        `attribute` can be an Attribute object, or a handle value
+        '''
+
+        # Send a request to read
+        attribute_handle = attribute if isinstance(attribute, int) else attribute.handle
+        response = await self.send_request(
+            ATT_Read_Request(attribute_handle=attribute_handle)
+        )
+        if response is None:
+            raise TimeoutError('read timeout')
+        if response.op_code == ATT_ERROR_RESPONSE:
+            raise ProtocolError(
+                response.error_code,
+                'att',
+                ATT_PDU.error_name(response.error_code),
+                response,
+            )
+
+        # If the value is the max size for the MTU, try to read more unless the caller
+        # specifically asked not to do that
+        attribute_value = response.attribute_value
+        if not no_long_read and len(attribute_value) == self.connection.att_mtu - 1:
+            logger.debug('using READ BLOB to get the rest of the value')
+            offset = len(attribute_value)
+            while True:
+                response = await self.send_request(
+                    ATT_Read_Blob_Request(
+                        attribute_handle=attribute_handle, value_offset=offset
+                    )
+                )
+                if response is None:
+                    raise TimeoutError('read timeout')
+                if response.op_code == ATT_ERROR_RESPONSE:
+                    if response.error_code in (
+                        ATT_ATTRIBUTE_NOT_LONG_ERROR,
+                        ATT_INVALID_OFFSET_ERROR,
+                    ):
+                        break
+                    raise ProtocolError(
+                        response.error_code,
+                        'att',
+                        ATT_PDU.error_name(response.error_code),
+                        response,
+                    )
+
+                part = response.part_attribute_value
+                attribute_value += part
+
+                if len(part) < self.connection.att_mtu - 1:
+                    break
+
+                offset += len(part)
+
+        # Return the value as bytes
+        return attribute_value
+
+    async def read_characteristics_by_uuid(self, uuid, service):
+        '''
+        See Vol 3, Part G - 4.8.2 Read Using Characteristic UUID
+        '''
+
+        if service is None:
+            starting_handle = 0x0001
+            ending_handle = 0xFFFF
+        else:
+            starting_handle = service.handle
+            ending_handle = service.end_group_handle
+
+        characteristics_values = []
+        while starting_handle <= ending_handle:
+            response = await self.send_request(
+                ATT_Read_By_Type_Request(
+                    starting_handle=starting_handle,
+                    ending_handle=ending_handle,
+                    attribute_type=uuid,
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(
+                        '!!! unexpected error while reading characteristics: '
+                        f'{HCI_Constant.error_name(response.error_code)}'
+                    )
+                    # TODO raise appropriate exception
+                    return []
+                break
+
+            # Stop if for some reason the list was empty
+            if not response.attributes:
+                break
+
+            # Process all characteristics returned in this iteration
+            for attribute_handle, attribute_value in response.attributes:
+                if attribute_handle < starting_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle value: {attribute_handle}')
+                    return []
+
+                characteristics_values.append(attribute_value)
+
+            # Move on to the next characteristics
+            starting_handle = response.attributes[-1][0] + 1
+
+        return characteristics_values
+
+    async def write_value(self, attribute, value, with_response=False):
+        '''
+        See Vol 3, Part G - 4.9.1 Write Without Response & 4.9.3 Write Characteristic
+        Value
+
+        `attribute` can be an Attribute object, or a handle value
+        '''
+
+        # Send a request or command to write
+        attribute_handle = attribute if isinstance(attribute, int) else attribute.handle
+        if with_response:
+            response = await self.send_request(
+                ATT_Write_Request(
+                    attribute_handle=attribute_handle, attribute_value=value
+                )
+            )
+            if response.op_code == ATT_ERROR_RESPONSE:
+                raise ProtocolError(
+                    response.error_code,
+                    'att',
+                    ATT_PDU.error_name(response.error_code),
+                    response,
+                )
+        else:
+            await self.send_command(
+                ATT_Write_Command(
+                    attribute_handle=attribute_handle, attribute_value=value
+                )
+            )
+
+    def on_gatt_pdu(self, att_pdu):
+        logger.debug(
+            f'GATT Response to client: [0x{self.connection.handle:04X}] {att_pdu}'
+        )
+        if att_pdu.op_code in ATT_RESPONSES:
+            if self.pending_request is None:
+                # Not expected!
+                logger.warning('!!! unexpected response, there is no pending request')
+                return
+
+            # Sanity check: the response should match the pending request unless it is
+            # an error response
+            if att_pdu.op_code != ATT_ERROR_RESPONSE:
+                expected_response_name = self.pending_request.name.replace(
+                    '_REQUEST', '_RESPONSE'
+                )
+                if att_pdu.name != expected_response_name:
+                    logger.warning(
+                        f'!!! mismatched response: expected {expected_response_name}'
+                    )
+                    return
+
+            # Return the response to the coroutine that is waiting for it
+            self.pending_response.set_result(att_pdu)
+        else:
+            handler_name = f'on_{att_pdu.name.lower()}'
+            handler = getattr(self, handler_name, None)
+            if handler is not None:
+                handler(att_pdu)
+            else:
+                logger.warning(
+                    color(
+                        '--- Ignoring GATT Response from '
+                        f'[0x{self.connection.handle:04X}]: ',
+                        'red',
+                    )
+                    + str(att_pdu)
+                )
+
+    def on_att_handle_value_notification(self, notification):
+        # Call all subscribers
+        subscribers = self.notification_subscribers.get(
+            notification.attribute_handle, []
+        )
+        if not subscribers:
+            logger.warning('!!! received notification with no subscriber')
+        for subscriber in subscribers:
+            if callable(subscriber):
+                subscriber(notification.attribute_value)
+            else:
+                subscriber.emit('update', notification.attribute_value)
+
+    def on_att_handle_value_indication(self, indication):
+        # Call all subscribers
+        subscribers = self.indication_subscribers.get(indication.attribute_handle, [])
+        if not subscribers:
+            logger.warning('!!! received indication with no subscriber')
+        for subscriber in subscribers:
+            if callable(subscriber):
+                subscriber(indication.attribute_value)
+            else:
+                subscriber.emit('update', indication.attribute_value)
+
+        # Confirm that we received the indication
+        self.send_confirmation(ATT_Handle_Value_Confirmation())