codecraftai-interop-ext-bluetooth 1.2.0__tar.gz

codecraftai_interop_ext_bluetooth-1.2.0/LICENSE.md

@@ -0,0 +1,204 @@
+# Code Craft AI - Source Available License
+Version 1.0, October 2026
+
+Copyright (C) 2026, Code Craft AI LLC
+
+Everyone is permitted to copy and distribute verbatim copies of *This License* document, but changing it is not allowed.
+
+*This License* covers the Python Automation Kit, the full suite of software published by *Licensor* that consists of every `codecraftai-*` package, every `pychestrate` package, and the `pychestrate` server.
+
+*The Software* is source available.  Its source code is published so that anyone can read it, learn from it, and use it, but *This License* is not an open source license.  *The Software* is free to use for *Non-Commercial Use*.  *Commercial Use* is permitted in exchange for a *Usage Fee* that is based on a reasonable estimation of the income derived from *The Software*, as described in section 5.  When a company migrates a product or service to *The Software* from another code base, the *Profit* from that product or service is not counted toward the *Usage Fee* for two years, as described in section 5.4.  For assurance of costs, a company can disclose its usage and estimated returns to *Licensor* and negotiate a fixed license cost, as described in section 5.10.
+
+## 1. Definitions
+
+### 1.1 *This License* or *The License*
+**This License** or **The License** refers to version 1.0 of the Code Craft AI - Source Available License.
+
+### 1.2 Licensor
+**Licensor** refers to Code Craft AI LLC.
+
+### 1.3 The Software
+**The Software** refers to the Python Automation Kit, the full suite of software that *Licensor* publishes under *This License*.  The Python Automation Kit consists of the following components (each, a **Component**), together with their source code, documentation, and other materials:
+
+1. Every Python package published by *Licensor* whose name begins with `codecraftai-`
+2. Every Python package published by *Licensor* whose name begins with `pychestrate`
+3. The `pychestrate` server
+
+### 1.4 You
+**You** refers to the individual or legal entity that exercises rights under *This License*.  When an individual exercises rights under *This License* on behalf of a company, organization, or other legal entity, **You** refers to that entity.
+
+### 1.5 Use
+**Use** means to install, execute, load, access, operate, display, copy, modify, configure, customize, and otherwise use.
+
+### 1.6 Non-Commercial Use
+**Non-Commercial Use** means any *Use* of *The Software* that is not *Commercial Use*.  Examples of *Non-Commercial Use* include personal use, hobby projects, study, teaching, academic research, evaluation, and use by a non-profit organization for its non-profit purposes.
+
+### 1.7 Commercial Use
+**Commercial Use** means any *Use* of *The Software* by or on behalf of a for-profit entity, and any *Use* of *The Software* in connection with a product, service, or activity that generates revenue.  *Commercial Use* includes, without limitation, *Use* of *The Software* to develop, build, test, validate, deploy, operate, or support commercial products and services, and *Use* of *The Software* to provide services to others.
+
+### 1.8 Commercial Activity
+**Commercial Activity** means the products, services, and business operations in connection with which *You* make *Commercial Use* of *The Software*.
+
+### 1.9 Fiscal Year
+**Fiscal Year** means the annual accounting period that *You* use for financial reporting.
+
+### 1.10 Profit
+**Profit** means the net profit that *You* earn from the *Commercial Activity* during a *Fiscal Year*, determined under the accounting principles that *You* regularly use for financial reporting.
+
+### 1.11 Contribution Estimate
+**Contribution Estimate** means *Your* reasonable, good faith estimate of the portion of the *Profit* that *The Software* contributed to, expressed as a number from 0 to 1.
+
+### 1.12 Derived Income
+**Derived Income** means the portion of the *Profit* for a *Fiscal Year* that is derived from *The Software*, calculated as described in section 5.2.
+
+### 1.13 Usage Fee
+**Usage Fee** means the yearly fee for *Commercial Use* that is set by the table in section 5.3.
+
+### 1.14 Migration
+**Migration** means moving the work for one of *Your* products or services from a code base other than *The Software*, such as another framework, another library, or *Your* own code, to *The Software*.
+
+### 1.15 Migration Period
+**Migration Period** means the two (2) year period, described in section 5.4, during which the *Profit* from a product or service that *You* are migrating to *The Software* is not counted.
+
+## 2. License Grant
+
+Subject to the terms and conditions of *This License*, *Licensor* hereby grants to *You* a non-exclusive, worldwide, non-transferable license to *Use*, copy, modify, create derivative works of, and distribute *The Software*.
+
+*Licensor* also grants to *You* a license under any patents that *Licensor* can license, and that are necessarily infringed by *The Software*, for the same purposes and subject to the same conditions as the license granted above.
+
+*This License* covers the Python Automation Kit as a whole.  *Use* of one, some, or all of the *Components* is *Use* of *The Software*.
+
+The licenses granted by *This License* are free of charge for *Non-Commercial Use*.  The licenses granted by *This License* for *Commercial Use* are conditioned on the payment of the *Usage Fee* described in section 5.
+
+## 3. Conditions
+
+### 3.1 License Notice
+Every copy of *The Software* that *You* distribute, in original or modified form, must include a complete copy of *This License* and must keep all copyright, patent, trademark, and attribution notices that appear in *The Software*.
+
+### 3.2 Recipients
+Anyone who receives *The Software* from *You* receives it under the terms of *This License*.  *You* may not impose terms on a recipient that conflict with *This License*, and *You* may not grant a recipient rights that *This License* does not grant to *You*.
+
+### 3.3 Modified Versions
+*You* must clearly mark any modified version of *The Software* as modified.  *The Software* is published by *Licensor* under a specific identity, such as a package name.  *You* may not publish a modified version of *The Software* under the identity that *Licensor* originally published it under.  Every copy of *The Software* that *You* redistribute under its original identity must be an exact copy of *The Software* as *Licensor* published it.
+
+### 3.4 Trademarks
+*This License* does not grant any rights to use the names, logos, or trademarks of *Licensor*, except as required to comply with section 3.1 and to describe the origin of *The Software*.
+
+## 4. Non-Commercial Use
+
+*Non-Commercial Use* of *The Software* is free.  No *Usage Fee*, registration, or report is required for *Non-Commercial Use*.
+
+## 5. Commercial Use
+
+### 5.1 Usage Fee Obligation
+For each *Fiscal Year* in which *You* make *Commercial Use* of *The Software*, *You* must pay *Licensor* a *Usage Fee*.  A single *Usage Fee* covers all of *Your* *Commercial Use* of the *Components*.  *Usage Fees* are not owed separately for each *Component*.
+
+### 5.2 Derived Income
+The *Derived Income* for a *Fiscal Year* is calculated as follows:
+
+    (Contribution Estimate) * (Profit) = (Derived Income)
+
+If *You* make *Commercial Use* of *The Software* for more than one product or service, calculate the *Derived Income* for each product or service using its own *Contribution Estimate* and *Profit*, and add the results together.  The *Profit* from a product or service that is in its *Migration Period* is not counted, as described in section 5.4.
+
+If the *Profit* from a product or service for a *Fiscal Year* is zero or less, then the *Derived Income* from that product or service for that *Fiscal Year* is zero.
+
+### 5.3 Usage Fee
+The *Usage Fee* for a *Fiscal Year* is set by the *Derived Income* for that *Fiscal Year*, as shown in the following table.
+
+| Derived Income for the Fiscal Year | Usage Fee per Fiscal Year |
+|------------------------------------|---------------------------|
+| 1,000,000 or less | Free |
+| More than 1,000,000, up to and including 10,000,000 | 50,000 |
+| More than 10,000,000, up to and including 100,000,000 | 100,000 |
+| More than 100,000,000, up to and including 1,000,000,000 | 250,000 |
+| More than 1,000,000,000 | 500,000 |
+
+All amounts in this section 5 are in United States dollars.  If *You* report *Profit* in a different currency, convert the *Derived Income* to United States dollars using the average exchange rate for the *Fiscal Year*.
+
+### 5.4 Migration Allowance
+When *You* migrate a product or service to *The Software*, the *Profit* from that product or service is not counted when calculating the *Derived Income* during its *Migration Period* (the **Migration Allowance**).
+
+The *Migration Period* for a product or service begins on the date that *You* first make *Commercial Use* of *The Software* for that product or service as part of its *Migration*, and ends two (2) years after that date.
+
+The *Migration Allowance* applies to each product or service separately, and *You* may use it for every product or service that *You* migrate.  Each product or service has only one *Migration Period*.
+
+If a *Fiscal Year* is only partly within the *Migration Period* of a product or service, the *Profit* from that product or service for that *Fiscal Year* is reduced in proportion to the number of days of that *Fiscal Year* that fall within its *Migration Period*.
+
+For example, a company tests product A with *The Software* and pays a *Usage Fee* based on the *Profit* from product A.  On March 1, 2027, the company begins moving the testing of product B from a different test framework to *The Software*.  The company does not count the *Profit* from product B in its *Derived Income* from March 1, 2027 until March 1, 2029.  Starting March 1, 2029, the *Profit* from product B is counted.  If the company later migrates product C, the *Profit* from product C is not counted for two years from the start of its own *Migration*.
+
+### 5.5 Contribution Estimate
+*You* are responsible for making the *Contribution Estimate*.  A *Contribution Estimate* must be reasonable and made in good faith.  The *Contribution Estimate* for a product or service covers all of the *Components* that *You* *Use* for that product or service.  When making the *Contribution Estimate*, *You* should consider how important *The Software* is to the *Commercial Activity*, how much of the *Commercial Activity* depends on *The Software*, and the effort and cost that *You* would otherwise need to spend to accomplish what *The Software* accomplishes for *You*.
+
+The following table is a guide for making the *Contribution Estimate*.  When *Your* *Commercial Use* of *The Software* matches an entry in the table, the *Contribution Estimate* in that entry is a reasonable *Contribution Estimate*.  When *Your* *Commercial Use* does not match an entry in the table, make the *Contribution Estimate* by comparing *Your* *Commercial Use* with the entries in the table.  When more than one entry matches the same *Commercial Activity*, use the entry with the highest *Contribution Estimate*.
+
+| Commercial Use of *The Software* | Contribution Estimate |
+|----------------------------------|-----------------------|
+| Quality Assurance (QA) and Continuous Integration (CI): *The Software* is used to test or validate the products or services of the *Commercial Activity*, or to run their build and test pipelines | 0.3 |
+| Products Completely Based on *The Software*: the products or services of the *Commercial Activity* are built completely on *The Software* | 0.5 |
+
+### 5.6 Examples
+A company earns 1,000,000,000 in *Profit* from a product line during a *Fiscal Year*.  The company uses *The Software* for the QA and CI of that product line, so the *Contribution Estimate* is 0.3.
+
+    0.3 * 1,000,000,000 = 300,000,000
+
+The *Derived Income* of 300,000,000 is more than 100,000,000 and not more than 1,000,000,000, so the *Usage Fee* for that *Fiscal Year* is 250,000.
+
+A company earns 4,000,000 in *Profit* from a product during a *Fiscal Year*.  The product is built completely on *The Software*, so the *Contribution Estimate* is 0.5.
+
+    0.5 * 4,000,000 = 2,000,000
+
+The *Derived Income* of 2,000,000 is more than 1,000,000 and not more than 10,000,000, so the *Usage Fee* for that *Fiscal Year* is 50,000.
+
+A company earns 3,000,000 in *Profit* from a product line during a *Fiscal Year*.  The company uses *The Software* for the QA and CI of that product line, so the *Contribution Estimate* is 0.3.
+
+    0.3 * 3,000,000 = 900,000
+
+The *Derived Income* of 900,000 is 1,000,000 or less, so there is no *Usage Fee* for that *Fiscal Year*.
+
+### 5.7 Reporting and Payment
+Within one hundred twenty (120) days after the end of each *Fiscal Year* for which a *Usage Fee* is owed, *You* must pay the *Usage Fee* to *Licensor* and provide *Licensor* with a written statement that shows the *Profit*, the *Contribution Estimate*, the reasoning used to make the *Contribution Estimate*, the *Derived Income*, and the *Usage Fee*.  *Usage Fees* are payable in United States dollars.  If any *Profit* is not counted under section 5.4, the statement must also identify each product or service that is in a *Migration Period* and show the dates of its *Migration Period*.  No statement is required for a *Fiscal Year* in which no *Usage Fee* is owed.
+
+### 5.8 Records and Review
+*You* must keep records that reasonably support each *Contribution Estimate*, each *Profit* figure, and the dates of any *Migration Period* for at least three (3) years after the end of the *Fiscal Year* that they apply to.  No more than once in any twelve (12) month period, *Licensor* may ask in writing for the records that support a statement, and *You* must provide them within sixty (60) days of the request.  *Licensor* will treat those records as confidential.
+
+### 5.9 Disputes About the Usage Fee
+If *Licensor* believes that a *Contribution Estimate*, a *Profit* figure, or the dates of a *Migration Period* are not reasonable, *Licensor* will notify *You* in writing and explain why.  *You* and *Licensor* will then negotiate in good faith for at least sixty (60) days to agree on a reasonable *Usage Fee*.  If *You* and *Licensor* cannot agree, either party may resolve the dispute as described in section 8.
+
+### 5.10 Fixed License Cost
+For assurance of costs, *You* may disclose to *Licensor* how *You* *Use* *The Software* and the returns that *You* estimate *You* will derive from it, and negotiate a fixed license cost with *Licensor*.  A fixed license cost, and any other terms that *You* and *Licensor* agree to, must be set out in a writing signed by both *You* and *Licensor* (a **Fixed License Agreement**).
+
+While a *Fixed License Agreement* is in effect, the fixed license cost replaces the *Usage Fee* for the *Commercial Use* that the *Fixed License Agreement* covers, and sections 5.7 through 5.9 apply to that *Commercial Use* only as the *Fixed License Agreement* provides.  To the extent that a *Fixed License Agreement* conflicts with this section 5, the *Fixed License Agreement* controls.
+
+*Licensor* will treat the information that *You* disclose under this section 5.10 as confidential.
+
+## 6. Termination
+
+If *You* violate *This License*, the licenses granted to *You* by *This License* end.  If *Licensor* notifies *You* in writing of the violation and *You* correct the violation within thirty (30) days of receiving the notice, including by paying any *Usage Fee* that is owed, then the licenses granted to *You* are reinstated.  This reinstatement is available to *You* only once.  Termination does not release *You* from any *Usage Fee* that is owed for *Commercial Use* that took place before the termination.
+
+## 7. No Warranty and Limitation of Liability
+
+### 7.1 No Warranty
+*THE SOFTWARE* IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
+
+### 7.2 Limitation of Liability
+TO THE EXTENT PERMITTED BY LAW, IN NO EVENT WILL *LICENSOR* BE LIABLE TO *YOU* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES OF ANY KIND ARISING OUT OF OR RELATED TO *THIS LICENSE* OR THE *USE* OF *THE SOFTWARE*, EVEN IF *LICENSOR* HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+### 7.3 Support
+*This License* does not entitle *You* to support, maintenance, or other services.  Support and services are available only under a separate written agreement with *Licensor*.
+
+## 8. Governing Law and Jurisdiction
+
+*This License* is governed by the laws of the State of Washington and the United States as though fully performed in Washington, without regard to provisions relating to conflicts of laws.  The UN Convention for the International Sale of Goods and the Uniform Computer Information Transactions Act (UCITA) will not apply.  The state and federal courts located in King County, Washington will have exclusive jurisdiction to adjudicate any disputes arising under *This License*, and *You* and *Licensor* agree to submit to the jurisdiction of those courts.
+
+## 9. General
+
+### 9.1 Severability
+If any provision of *This License* is held to be unenforceable, that provision will be enforced to the maximum extent permitted, and the remaining provisions of *This License* will remain in effect.
+
+### 9.2 Interpretation
+The section headings in *This License* are for reference purposes only and do not modify or restrict any term of *This License*.  *This License* is written in the English language, and the English text prevails over any translation.
+
+### 9.3 Contact
+Questions about *This License*, *Usage Fee* statements, payments, and requests to negotiate a *Fixed License Agreement* may be sent to *Licensor* using the contact information published at:
+
+    https://code-craft.ai

codecraftai_interop_ext_bluetooth-1.2.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: codecraftai-interop-ext-bluetooth
+Version: 1.2.0
+Summary: Code Craft AI Interop Extension for Bluetooth
+License-Expression: LicenseRef-CodeCraftAI-Source-Available
+License-File: LICENSE.md
+Keywords: python
+Author: Myron Walker
+Author-email: myron.walker@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Requires-Dist: bumble (>=0.0.223,<0.0.224)
+Requires-Dist: codecraftai-interop (<2.0.0)
+Requires-Dist: codecraftai-landscaping (<2.0.0)
+Project-URL: Issues, https://github.com/code-craft-ai-company/codecraftai-interop-ext-bluetooth/issues
+Project-URL: Repository, https://github.com/code-craft-ai-company/codecraftai-interop-ext-bluetooth
+Description-Content-Type: text/x-rst
+
+==============================================
+Code Craft AI Interop Extension: Bluetooth
+==============================================
+
+The ``codecraftai-interop-ext-bluetooth`` package provides Bluetooth protocol interop extensions and landscape extensions that allow for interoperability with Bluetooth devices during automation runs. It plugs into the ``codecraftai-interop`` and ``codecraftai-landscaping`` frameworks through the extension mechanism in ``codecraftai-extension``.
+
+Highlights
+==========
+
+- Bluetooth protocol handlers under ``interop/bluetooth/``.
+- Landscape extension hooks so Bluetooth devices surface as first-class landscape resources.
+- Composable with other ``codecraftai-interop-ext-*`` packages through the shared extension mechanism.
+
+Repository Structure
+====================
+
+- ``development/`` - Runtime environment scripts.
+- ``repository-setup/`` - Repository homing and setup scripts.
+- ``source/packages/`` - Package source code.
+- ``source/testroots/ccai/`` - TestBase test roots.
+- ``userguide/`` - Standards, conventions, and documentation.
+
+Environment Setup
+=================
+
+When working in a Codex container:
+
+.. code-block:: bash
+
+   ./development/setup-agent-container
+
+For local development:
+
+.. code-block:: bash
+
+   ./repository-setup/rehome-repository
+   ./development/setup-envrionment
+
+Running Tests
+=============
+
+Activate the virtual environment:
+
+.. code-block:: bash
+
+   source .venv/bin/activate
+
+Run the single-host test suite:
+
+.. code-block:: bash
+
+   testbase testing run --root source/testroots/ccai --includes=ccai.tests.singlehost.interop --output=./.output
+
+Standards and Conventions
+=========================
+
+- Naming conventions: ``userguide/10-02-naming-conventions.rst``
+- Code organization: ``userguide/10-01-code-organization.rst``
+- Coding standards: ``userguide/10-00-coding-standards.rst``
+
+Additional Resources
+====================
+
+- User guide entry point: ``userguide/userguide.rst``
+

codecraftai_interop_ext_bluetooth-1.2.0/README.rst

@@ -0,0 +1,64 @@
+==============================================
+Code Craft AI Interop Extension: Bluetooth
+==============================================
+
+The ``codecraftai-interop-ext-bluetooth`` package provides Bluetooth protocol interop extensions and landscape extensions that allow for interoperability with Bluetooth devices during automation runs. It plugs into the ``codecraftai-interop`` and ``codecraftai-landscaping`` frameworks through the extension mechanism in ``codecraftai-extension``.
+
+Highlights
+==========
+
+- Bluetooth protocol handlers under ``interop/bluetooth/``.
+- Landscape extension hooks so Bluetooth devices surface as first-class landscape resources.
+- Composable with other ``codecraftai-interop-ext-*`` packages through the shared extension mechanism.
+
+Repository Structure
+====================
+
+- ``development/`` - Runtime environment scripts.
+- ``repository-setup/`` - Repository homing and setup scripts.
+- ``source/packages/`` - Package source code.
+- ``source/testroots/ccai/`` - TestBase test roots.
+- ``userguide/`` - Standards, conventions, and documentation.
+
+Environment Setup
+=================
+
+When working in a Codex container:
+
+.. code-block:: bash
+
+   ./development/setup-agent-container
+
+For local development:
+
+.. code-block:: bash
+
+   ./repository-setup/rehome-repository
+   ./development/setup-envrionment
+
+Running Tests
+=============
+
+Activate the virtual environment:
+
+.. code-block:: bash
+
+   source .venv/bin/activate
+
+Run the single-host test suite:
+
+.. code-block:: bash
+
+   testbase testing run --root source/testroots/ccai --includes=ccai.tests.singlehost.interop --output=./.output
+
+Standards and Conventions
+=========================
+
+- Naming conventions: ``userguide/10-02-naming-conventions.rst``
+- Code organization: ``userguide/10-01-code-organization.rst``
+- Coding standards: ``userguide/10-00-coding-standards.rst``
+
+Additional Resources
+====================
+
+- User guide entry point: ``userguide/userguide.rst``

codecraftai_interop_ext_bluetooth-1.2.0/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "codecraftai-interop-ext-bluetooth"
+version = "1.2.0"
+description = "Code Craft AI Interop Extension for Bluetooth"
+readme = "README.rst"
+license = "LicenseRef-CodeCraftAI-Source-Available"
+authors = [{name = "Myron Walker", email = "myron.walker@gmail.com"}]
+keywords = [
+    "python"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: POSIX",
+]
+requires-python = ">=3.10,<4.0"
+dependencies = [
+    "codecraftai-interop<2.0.0",
+    "codecraftai-landscaping<2.0.0",
+    "bumble>=0.0.223,<0.0.224",
+]
+
+[project.urls]
+Repository = "https://github.com/code-craft-ai-company/codecraftai-interop-ext-bluetooth"
+Issues = "https://github.com/code-craft-ai-company/codecraftai-interop-ext-bluetooth/issues"
+
+[dependency-groups]
+dev = []
+
+[tool.poetry]
+packages = [{include="ccai", from="source/packages"}]
+
+[tool.poetry.dependencies]
+codecraftai-interop = {source = "codecraftai"}
+codecraftai-landscaping = {source = "codecraftai"}
+
+[[tool.poetry.source]]
+name = "codecraftai"
+url = "https://code-craft.ai/licensed-repository/simple/"
+priority = "supplemental"
+
+[[tool.uv.index]]
+# Same licensed index as [[tool.poetry.source]]. Listed before PyPI so that
+# codecraftai-* packages (direct and transitive) resolve from it; everything
+# else falls through to PyPI. Credentials: UV_INDEX_CODECRAFTAI_USERNAME /
+# UV_INDEX_CODECRAFTAI_PASSWORD, or `uv auth login`.
+name = "codecraftai"
+url = "https://code-craft.ai/licensed-repository/simple/"
+
+[tool.ruff.lint]
+# Deliberately narrow.  This gate exists for one reason: a bare `except:`
+# swallows ConfigurationError and SemanticError, which derive from
+# BaseException precisely so that they pass through ordinary handlers and end
+# the run.  Catching them hides the original cause behind whatever error
+# happens next.  See userguide/10-00-coding-standards.rst, exception-handling
+# rules 5-7.  Use `except Exception:` when you mean "any ordinary failure".
+select = ["E722"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

codecraftai_interop_ext_bluetooth-1.2.0/source/packages/ccai/interop/bluetooth/__init__.py

@@ -0,0 +1,13 @@
+from .bluetoothcoordinator import BluetoothCoordinator
+from .bluetoothpresence import BluetoothPresence
+from .bluetoothdevice import BluetoothDevice
+from .bluetoothsearchwindow import BluetoothSearchWindow
+from .deviceevidence import BluetoothDeviceEvidence
+
+__all__ = [
+    "BluetoothCoordinator",
+    "BluetoothPresence",
+    "BluetoothDevice",
+    "BluetoothSearchWindow",
+    "BluetoothDeviceEvidence",
+]

codecraftai_interop_ext_bluetooth-1.2.0/source/packages/ccai/interop/bluetooth/bluetoothcoordinator.py

@@ -0,0 +1,137 @@
+import logging
+import asyncio
+import threading
+from concurrent.futures import Future
+from bumble.device import Device
+from bumble.transport import open_transport_or_link
+
+logger = logging.getLogger(__name__)
+
+class BluetoothCoordinator:
+    """
+    Coordinator for Bluetooth operations using Bumble.
+    Manages its own background thread and asyncio loop to provide a synchronous API.
+    """
+    def __init__(self, transport_address="usb:0", device_config=None):
+        self.transport_address = transport_address
+        self.device_config = device_config or {
+            "name": "MojoBluetooth",
+            "address": "F0:F1:F2:F3:F4:F5"
+        }
+        self.device = None
+        self.transport = None
+
+        self._loop = None
+        self._loop_thread = None
+        self._running = False
+
+    def startup(self):
+        """
+        Starts the coordinator and its background loop.
+        """
+        if self._running:
+            return
+
+        logger.info(f"Starting Bluetooth Coordinator with transport: {self.transport_address}")
+
+        self._running = True
+        self._loop = asyncio.new_event_loop()
+        self._loop_thread = threading.Thread(target=self._run_loop, args=(self._loop,), daemon=True, name="am-bt-coordinator-loop")
+        self._loop_thread.start()
+
+        try:
+            self.submit_coroutine(self._async_startup())
+            logger.info("Bluetooth Coordinator started")
+        except Exception as e:
+            logger.error(f"Failed to start Bluetooth coordinator: {e}")
+            self.shutdown()
+            raise
+
+    def shutdown(self):
+        """
+        Stops the coordinator and its background loop.
+        """
+        logger.info("Stopping Bluetooth Coordinator")
+
+        if self._loop and self._loop.is_running():
+            try:
+                self.submit_coroutine(self._async_shutdown())
+            except Exception as e:
+                logger.warning(f"Error during async shutdown: {e}")
+
+            self._loop.call_soon_threadsafe(self._loop.stop)
+
+        if self._loop_thread and self._loop_thread.is_alive():
+            self._loop_thread.join(timeout=5.0)
+            if self._loop_thread.is_alive():
+                 logger.warning("Bluetooth Coordinator loop thread did not exit cleanly")
+
+        self._running = False
+        self._loop = None
+        self._loop_thread = None
+
+    def start_scanning(self, filter_duplicates=True):
+        self.submit_coroutine(self._async_start_scanning(filter_duplicates))
+
+    def stop_scanning(self):
+        self.submit_coroutine(self._async_stop_scanning())
+
+    def submit_coroutine(self, coro, timeout=10.0):
+        """
+        Submits a coroutine to the background loop and waits for the result.
+        """
+        if not self._loop:
+            raise RuntimeError("Coordinator loop not running")
+
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return future.result(timeout=timeout)
+
+    def _run_loop(self, loop):
+        asyncio.set_event_loop(loop)
+        loop.run_forever()
+
+    async def _async_startup(self):
+        # Initialize Bumble device
+        name = self.device_config.get("name", "MojoBluetooth")
+        address = self.device_config.get("address", "F0:F1:F2:F3:F4:F5")
+
+        # Open the transport first, then build the device wired to the
+        # transport's HCI source/sink. Device.with_hci constructs the Host
+        # internally; there is no separate attach/sink step in bumble.
+        self.transport = await open_transport_or_link(self.transport_address)
+
+        self.device = Device.with_hci(
+            name, address, self.transport.source, self.transport.sink
+        )
+
+        await self.device.power_on()
+
+    async def _async_shutdown(self):
+        if self.device:
+            try:
+                await self.device.power_off()
+            except Exception as e:
+                logger.warning(f"Error powering off device: {e}")
+
+        if self.transport:
+            try:
+                await self.transport.close()
+            except Exception as e:
+                logger.warning(f"Error closing transport: {e}")
+
+        self.device = None
+        self.transport = None
+
+    async def _async_start_scanning(self, filter_duplicates=True):
+        if not self.device:
+            raise RuntimeError("Device not initialized")
+
+        logger.info("Starting scanning (async)")
+        await self.device.start_scanning(filter_duplicates=filter_duplicates)
+
+    async def _async_stop_scanning(self):
+        if not self.device:
+            return
+
+        logger.info("Stopping scanning (async)")
+        await self.device.stop_scanning()

codecraftai_interop_ext_bluetooth-1.2.0/source/packages/ccai/interop/bluetooth/bluetoothdevice.py

@@ -0,0 +1,69 @@
+import logging
+from typing import Optional
+from .bluetoothcoordinator import BluetoothCoordinator
+from .deviceevidence import BluetoothDeviceEvidence
+
+logger = logging.getLogger(__name__)
+
+class BluetoothDevice:
+    """
+    Represents a specific Bluetooth device.
+    """
+    def __init__(self, address: str, coordinator: BluetoothCoordinator):
+        self.address = address
+        self.coordinator = coordinator
+        self.connection = None
+        self._evidence: Optional[BluetoothDeviceEvidence] = None
+
+    @property
+    def evidence(self) -> Optional[BluetoothDeviceEvidence]:
+        return self._evidence
+
+    def update_evidence(self, evidence: BluetoothDeviceEvidence):
+        """
+        Updates the key evidence for the device (RSSI, name, etc.)
+        """
+        self._evidence = evidence
+
+    def connect(self):
+        """
+        Connects to the device.
+        """
+        logger.info(f"Connecting to device {self.address}")
+        # Execute the connection on the coordinator's loop
+        self.connection = self.coordinator.submit_coroutine(self._async_connect())
+        logger.info(f"Connected to {self.address}")
+        return self.connection
+
+    async def _async_connect(self):
+        if not self.coordinator.device:
+             raise RuntimeError("Coordinator not initialized. Call startup() on coordinator first.")
+        return await self.coordinator.device.connect(self.address)
+
+    def disconnect(self):
+        """
+        Disconnects from the device.
+        """
+        if self.connection:
+            logger.info(f"Disconnecting from {self.address}")
+            self.coordinator.submit_coroutine(self._async_disconnect())
+            self.connection = None
+
+    async def _async_disconnect(self):
+        if self.connection:
+            await self.connection.disconnect()
+
+    def pair(self):
+        """
+        Pairs with the device.
+        """
+        logger.info(f"Pairing with {self.address}")
+        self.coordinator.submit_coroutine(self._async_pair())
+
+    async def _async_pair(self):
+        if not self.connection:
+            # Capture the connection: _async_connect() returns it but does not
+            # assign self.connection (only the sync connect() wrapper does), so
+            # without this the pair() call below dereferences None.
+            self.connection = await self._async_connect()
+        await self.connection.pair()

codecraftai_interop_ext_bluetooth-1.2.0/source/packages/ccai/interop/bluetooth/bluetoothpresence.py

@@ -0,0 +1,222 @@
+
+import logging
+import threading
+import uuid
+import weakref
+from typing import Dict, List, Optional
+from datetime import datetime, timedelta
+
+from bumble.core import AdvertisingData
+
+from .bluetoothcoordinator import BluetoothCoordinator
+from .bluetoothsearchwindow import BluetoothSearchWindow
+from .bluetoothdevice import BluetoothDevice
+from .deviceevidence import BluetoothDeviceEvidence
+
+logger = logging.getLogger(__name__)
+
+# Advertising data structure types that carry lists of service class UUIDs.
+SERVICE_UUID_LIST_TYPES = (
+    AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+    AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+    AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS,
+    AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS,
+    AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS,
+    AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS,
+)
+
+
+def extract_local_name(data: AdvertisingData) -> Optional[str]:
+    """
+        Reads the advertised local name out of bumble advertising data, preferring the
+        complete local name over the shortened one.
+
+        :param data: The parsed advertising data of an advertisement.
+
+        :returns: The advertised name, or ``None`` when the advertisement carries none.
+    """
+    name = data.get(AdvertisingData.COMPLETE_LOCAL_NAME)
+    if name is None:
+        name = data.get(AdvertisingData.SHORTENED_LOCAL_NAME)
+    return name
+
+
+def extract_service_uuids(data: AdvertisingData) -> List[str]:
+    """
+        Collects every distinct service class UUID advertised in bumble advertising data as a
+        hex string (``"1800"`` for 16-bit UUIDs, the full 32 hex digits for 128-bit ones).
+
+        An active scan hands over the advertising packet and the scan response as one
+        accumulated advertisement, so the same list can appear twice; each UUID is kept once.
+
+        :param data: The parsed advertising data of an advertisement.
+
+        :returns: The list of advertised service UUIDs, in first-seen order.
+    """
+    service_uuids = []
+    for list_type in SERVICE_UUID_LIST_TYPES:
+        for uuid_list in data.get_all(list_type):
+            for service_uuid in uuid_list:
+                uuid_text = service_uuid.to_hex_str()
+                if uuid_text not in service_uuids:
+                    service_uuids.append(uuid_text)
+    return service_uuids
+
+
+class BluetoothPresence:
+    """
+    Manages Bluetooth presence and discovery using a background thread (via Coordinator)
+    and provides a synchronous, thread-safe API.
+    """
+    def __init__(self, coordinator: BluetoothCoordinator):
+        self._coordinator = coordinator
+        self._lock = threading.Lock()
+        
+        self._running = False
+        
+        # Data storage
+        self._discovered_devices: Dict[str, BluetoothDevice] = {} # Persistent cache
+        self._search_windows: Dict[str, weakref.ref] = {}
+        
+    @property
+    def is_running(self) -> bool:
+        return self._running
+        
+    @property
+    def discovered_devices(self) -> Dict[str, BluetoothDevice]:
+        # Return a shallow copy of the mapping. The BluetoothDevice values are
+        # live shared handles -- each holds the coordinator's asyncio loop, a
+        # thread, and a lock -- so they must NOT be deep-copied (deepcopy raises
+        # TypeError trying to pickle the event loop's context).
+        with self._lock:
+            devices = dict(self._discovered_devices)
+        return devices
+
+    def start(self):
+        """
+        Starts the Bluetooth presence manager.
+        """
+        with self._lock:
+            if self._running:
+                return
+            
+            self._running = True
+            
+            # Initialize coordinator
+            try:
+                self._coordinator.startup()
+            except Exception as e:
+                logger.error(f"Failed to start Bluetooth coordinator: {e}")
+                self._running = False
+                raise
+            
+            # Start continuous scanning
+            # We need to register the callback.
+            # Ideally this should be done safely on the loop.
+            # Using submit_coroutine to register callback is tricky because 'on' is not async usually.
+            # However, Bumble 'on' just appends to a list.
+            # We can define a coroutine to register it to be safe.
+            self._coordinator.submit_coroutine(self._register_callback_and_scan())
+
+
+    def stop(self):
+        """
+        Stops the Bluetooth presence manager.
+        """
+        with self._lock:
+            if not self._running:
+                return
+            self._running = False
+        
+        try:
+            self._coordinator.stop_scanning()
+            self._coordinator.shutdown()
+        except Exception as e:
+            logger.warning(f"Error stopping coordinator: {e}")
+
+
+    async def _register_callback_and_scan(self):
+        # Setup callback
+        if hasattr(self._coordinator.device, 'on'):
+             self._coordinator.device.on('advertisement', self._on_advertisement)
+        
+        await self._coordinator._async_start_scanning()
+
+    def _on_advertisement(self, entry):
+        """
+        Callback from Bumble when an advertisement is received.
+        Executed in the coordinator's loop thread.
+        """
+        try:
+            address = str(entry.address)
+            rssi = getattr(entry, 'rssi', 0)
+            
+            # Extract basic info from entry if possible
+            name = None
+            service_uuids = []
+            
+            if hasattr(entry, 'data'):
+                # bumble exposes the parsed structures through AdvertisingData.get /
+                # get_all; there is no get_local_name() or service_uuids attribute.
+                name = extract_local_name(entry.data)
+                service_uuids = extract_service_uuids(entry.data)
+            
+            # Create Evidence
+            evidence = BluetoothDeviceEvidence(
+                address=address,
+                rssi=rssi,
+                name=name,
+                service_uuids=service_uuids
+            )
+
+            with self._lock:
+                if address not in self._discovered_devices:
+                    # New device
+                    device = BluetoothDevice(address, self._coordinator)
+                    device.update_evidence(evidence)
+                    self._discovered_devices[address] = device
+                    logger.debug(f"Discovered new Bluetooth device: {address} ({name})")
+                else:
+                    device = self._discovered_devices[address]
+                    device.update_evidence(evidence)
+                
+                # Notify active search windows
+                windows_to_notify = []
+                for wid, wref in list(self._search_windows.items()):
+                    window = wref()
+                    if window is None:
+                        del self._search_windows[wid]
+                        continue
+                    
+                    if window.is_open():
+                        windows_to_notify.append(window)
+
+            # Notify windows
+            for window in windows_to_notify:
+                window.add_device(address, device)
+                
+        except Exception as e:
+            logger.error(f"Error handling advertisement: {e}")
+
+
+    def discover_devices(self, limit_to: List[str]=None, window_length: float = 10.0,
+                         monitor_interval: float = 0.5) -> BluetoothSearchWindow:
+        """
+        Opens a search window for devices.
+        Returns a BluetoothSearchWindow.
+        """
+        if not self._running:
+            raise RuntimeError("BluetoothPresence must be running. Call start().")
+
+        start = datetime.now()
+        end = start + timedelta(seconds=window_length)
+        wid = str(uuid.uuid4())
+
+        window = BluetoothSearchWindow(self, wid, start, end, monitor_interval, limit_to=limit_to)
+        
+        with self._lock:
+            self._search_windows[wid] = weakref.ref(window)
+        
+        window.start()
+        
+        return window

codecraftai_interop_ext_bluetooth-1.2.0/source/packages/ccai/interop/bluetooth/bluetoothsearchwindow.py

@@ -0,0 +1,277 @@
+
+"""
+    .. module:: bluetoothsearchwindow
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: bluetoothsearchwindow module.
+    
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+
+from typing import Dict, List, Optional, TYPE_CHECKING
+import threading
+import time
+import weakref
+from datetime import datetime
+
+# We will need a BluetoothDeviceDetail similar to UpnpDeviceDetail, 
+# for now using generic dict or we might need to create it.
+# The user asked to "Make sure it is using a windows similar to the upnp code"
+# so I will assume we might need a similar detail object, but for now I will use the 
+# existing BluetoothDevice or a new detail class if I create one. 
+# The prompt mentioned "Modify the BluetoothPresence object to utilize the Bumble package... 
+# Make sure the BluetoothPresence object has a way to scan for BLE devices and Bluetooth classic"
+
+if TYPE_CHECKING:
+    from ccai.interop.bluetooth.bluetoothpresence import BluetoothPresence
+    from ccai.interop.bluetooth.bluetoothdevice import BluetoothDevice
+
+
+def normalize_address_hint(hint: str) -> str:
+    """
+        Normalises a device address so that hints supplied by callers compare equal to the
+        address keys produced from bumble advertisements.  bumble renders public addresses
+        with a type qualifier (``AA:BB:CC:DD:EE:FF/P``) while callers naturally supply the
+        bare address; letter case and surrounding whitespace are ignored as well.
+
+        :param hint: A device address, with or without bumble's ``/P`` qualifier.
+
+        :returns: The upper-cased bare address.
+    """
+    normalized = hint.strip().upper()
+    if normalized.endswith("/P"):
+        normalized = normalized[:-2]
+    return normalized
+
+
+class BluetoothSearchWindowState:
+    """
+        Enumeration describing the lifecycle of a Bluetooth search window.
+    """
+    INACTIVE = 0
+    ACTIVE = 1
+    COMPLETED = 2
+    TIMEOUT = 3
+
+
+class BluetoothSearchWindow:
+    """
+        The BluetoothSearchWindow class provides a synchronization and state managment device for synchronizing the state of Bluetooth search
+        activities.
+    """
+
+    def __init__(self, presence: "BluetoothPresence", id: str, start: datetime, end: datetime, monitor_interval: float, limit_to: List[str]=None):
+        """
+            :param presence: The owning :class:`BluetoothPresence` instance.
+            :param id: Identifier for this search window.
+            :param start: Start time of the search window.
+            :param end: End time of the search window.
+            :param monitor_interval: Polling interval for window monitoring.
+            :param limit_to: Optional list of device addresses to limit the search.
+        """
+
+        self._presence_ref = weakref.ref(presence)
+        self._id = id
+        self._start = start
+        self._end = end
+        self._monitor_interval = monitor_interval
+        self._limit_to = limit_to
+
+        self._still_waiting_for = None
+        if limit_to is not None:
+            self._still_waiting_for = [hint for hint in limit_to]
+
+        self._window_state = BluetoothSearchWindowState.INACTIVE
+
+        self._lock = threading.Lock()
+        self._wait_gate = threading.Event()
+        self._monitor_thread = None
+
+        self._devices_found = {}
+        self._matching_devices = {}
+        
+        return
+
+    @property
+    def devices_found(self) -> Dict[str, "BluetoothDevice"]:
+        """
+            The dictionary of devices found during the search window.
+            :returns: Copy of the devices found mapping.
+        """
+        with self._lock:
+            rtnval = self._devices_found.copy()
+        return rtnval
+
+    @property
+    def id(self) -> str:
+        """
+            The ID of the search window.
+        """
+        return self._id
+    
+    @property
+    def matching_devices(self) -> Dict[str, "BluetoothDevice"]:
+        """
+            The dictionary of devices that matched the search window criteria.
+        """
+        with self._lock:
+            rtnval = self._matching_devices.copy()
+        return rtnval
+
+    @property
+    def presence(self) -> Optional["BluetoothPresence"]:
+        """
+            The :class:`BluetoothPresence` object that is associated with this search window.
+            Returns None if the presence object has been garbage collected.
+        """
+        return self._presence_ref()
+
+
+    def add_device(self, identifier: str, device: "BluetoothDevice"):
+        """
+            Add a device to the list of devices found during the search window.
+
+            :param identifier: The identifier (e.g. address) for the device being added.
+            :param device: The device object.
+        """
+
+        with self._lock:
+            self._devices_found[identifier] = device
+
+        return
+
+
+    def is_active(self) -> bool:
+        """
+            Check if the search window is active.
+        """
+
+        with self._lock:
+            return self._window_state == BluetoothSearchWindowState.ACTIVE
+
+    def is_open(self) -> bool:
+        """
+            Check if the search window is open (INACTIVE or ACTIVE).
+        """
+        with self._lock:
+            return self._window_state in (BluetoothSearchWindowState.INACTIVE, BluetoothSearchWindowState.ACTIVE)
+
+    def start(self):
+        """
+            Begin monitoring for search results in a background thread.
+        """
+        self._lock.acquire()
+        try:
+            start_gate = threading.Event()
+            start_gate.clear()
+
+            self._monitor_thread = threading.Thread(target=self._monitor_thread_entry, name="am-bt-search-window-mon", args=(start_gate,), daemon=True)
+            self._monitor_thread.start()
+        finally:
+            self._lock.release()
+
+        start_gate.wait()
+
+        return
+
+
+    def wait(self, timeout: float = None) -> bool:
+        """
+            Wait for the search window to close.
+
+            :param timeout: The time in seconds to wait for the search window to close.  If None, then wait indefinitely.
+
+            :returns: ``True`` if the window closed before timeout, otherwise ``False``.
+        """
+
+        # Check initial state
+        with self._lock:
+            if self._window_state == BluetoothSearchWindowState.INACTIVE:
+                raise RuntimeError("The search window is not active.")
+            
+            if self._window_state != BluetoothSearchWindowState.ACTIVE:
+                # Window is already completed or timed out
+                return True
+
+        # Wait for completion without holding the lock
+        completed_successfully = self._wait_gate.wait(timeout=timeout)
+
+        return completed_successfully
+
+
+    def _monitor_thread_entry(self, sgate: threading.Event):
+        """
+            The monitor thread entry point.
+        """
+
+        with self._lock:
+            self._window_state = BluetoothSearchWindowState.ACTIVE
+            self._wait_gate.clear()
+
+        sgate.set()
+
+        while True:
+            with self._lock:
+                if self._window_state != BluetoothSearchWindowState.ACTIVE:
+                    break
+            
+            now = datetime.now()
+
+            if now > self._end:
+                with self._lock:
+                    self._window_state = BluetoothSearchWindowState.TIMEOUT
+                break
+
+            # Get current state atomically
+            with self._lock:
+                if self._still_waiting_for is not None:
+                    checking_for = [hint for hint in self._still_waiting_for]
+                    current_found = self._devices_found.copy()
+                else:
+                    checking_for = None
+                    current_found = {}
+
+            # Process hints
+            if checking_for is not None:
+                # Hints are device addresses.  Compare them in normalised form so a bare
+                # address hint matches the qualified key bumble produces (see normalize_address_hint).
+                found_by_normalized_address = {}
+                for found_identifier, found_device in current_found.items():
+                    normalized_identifier = normalize_address_hint(found_identifier)
+                    found_by_normalized_address[normalized_identifier] = found_device
+
+                matched_hints = []
+                matched_devices = {}
+
+                for nxt_hint in checking_for:
+                    normalized_hint = normalize_address_hint(nxt_hint)
+                    if normalized_hint in found_by_normalized_address:
+                        matched_hints.append(nxt_hint)
+                        matched_devices[nxt_hint] = found_by_normalized_address[normalized_hint]
+
+                # Update shared state atomically
+                with self._lock:
+                    if self._still_waiting_for is not None:
+                        for matched_hint in matched_hints:
+                            if matched_hint in self._still_waiting_for:
+                                self._still_waiting_for.remove(matched_hint)
+                    
+                    self._matching_devices.update(matched_devices)
+
+                    if self._still_waiting_for is not None and len(self._still_waiting_for) == 0:
+                        self._window_state = BluetoothSearchWindowState.COMPLETED
+                        break
+
+            time.sleep(self._monitor_interval)
+
+        self._wait_gate.set()
+
+        # You might want to callback to presence here if needed, 
+        # but for now we won't strictly enforce a search_window_closed callback 
+        # unless we add it to Presence.
+        
+        return

codecraftai_interop_ext_bluetooth-1.2.0/source/packages/ccai/interop/bluetooth/deviceevidence.py

@@ -0,0 +1,71 @@
+
+"""
+    .. module:: bluetoothdeviceevidence
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: Module containing the BluetoothDeviceEvidence object.
+    
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+    
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+class BluetoothDeviceEvidence:
+    """
+        A :class:`BluetoothDeviceEvidence` object is used to track evidence of the current state of Bluetooth devices.
+    """
+
+    def __init__(self, address: str, rssi: int, name: Optional[str] = None, 
+                 service_uuids: Optional[List[str]] = None, 
+                 manufacturer_data: Optional[Dict[int, bytes]] = None,
+                 timestamp: Optional[datetime] = None):
+        """
+            Initialize evidence.
+        """
+        self._address = address
+        self._rssi = rssi
+        self._name = name
+        self._service_uuids = service_uuids or []
+        self._manufacturer_data = manufacturer_data or {}
+        self._timestamp = timestamp if timestamp else datetime.now()
+
+    @property
+    def address(self) -> str:
+        return self._address
+
+    @property
+    def rssi(self) -> int:
+        return self._rssi
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def service_uuids(self) -> List[str]:
+        return self._service_uuids
+    
+    @property
+    def manufacturer_data(self) -> Dict[int, bytes]:
+        return self._manufacturer_data
+
+    @property
+    def timestamp(self) -> datetime:
+        return self._timestamp
+    
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "address": self._address,
+            "rssi": self._rssi,
+            "name": self._name,
+            "service_uuids": self._service_uuids,
+            "timestamp": self._timestamp.isoformat()
+        }
+
+    def __str__(self):
+        return f"<BluetoothDeviceEvidence address={self._address} rssi={self._rssi} name={self._name}>"