libmdr-bt 0.1.0__tar.gz

libmdr_bt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mos9527, Amr Satrio and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libmdr_bt-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: libmdr-bt
+Version: 0.1.0
+Summary: Python binding for libmdr-bt (Sony headphones platform connection backend)
+License-Expression: MIT
+Project-URL: Source, https://github.com/mos9527/libmdr-py
+Requires-Python: >=3.10
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: libmdr
+Dynamic: license-file
+
+ctypes bindings for libmdr-bt (mdr-bt-shared).

libmdr_bt-0.1.0/README.md

@@ -0,0 +1 @@
+# libmdr-bt

libmdr_bt-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "libmdr-bt"
+version = "0.1.0"
+description = "Python binding for libmdr-bt (Sony headphones platform connection backend)"
+readme = { text = "ctypes bindings for libmdr-bt (mdr-bt-shared).", content-type = "text/plain" }
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["libmdr"]
+
+[project.urls]
+Source = "https://github.com/mos9527/libmdr-py"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+libmdr_bt = ["_native/*"]
+
+# See libmdr/pyproject.toml: wheels are py3-none-<platform>, built once per platform.
+[tool.cibuildwheel]
+skip = ["*-musllinux_*", "cp31[1-9]*-manylinux_armv7l"]  # armv7l runs under QEMU: test once
+build-verbosity = 1
+test-command = "python -c \"import libmdr_bt, libmdr_bt._dll as d; print(d.load())\""
+manylinux-armv7l-image = "manylinux_2_35"
+
+[tool.cibuildwheel.linux]
+# The BlueZ backend talks to the system bluetoothd over D-Bus.
+before-all = "sh {project}/tooling/ci/linux-before-all.sh bt"
+# libdbus-1 / libbluetooth must match the host's dbus-daemon / bluetoothd (and
+# libbluetooth is GPL), so they are used from the system instead of vendored.
+repair-wheel-command = "auditwheel repair --exclude libdbus-1.so.3 --exclude libbluetooth.so.3 -w {dest_dir} {wheel}"
+
+[tool.cibuildwheel.macos]
+environment = { MACOSX_DEPLOYMENT_TARGET = "12.0" }
+
+[tool.cibuildwheel.windows]
+# No Python extension modules; mdr-bt-shared.dll links the CRT statically.
+repair-wheel-command = ""

libmdr_bt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

libmdr_bt-0.1.0/setup.py

@@ -0,0 +1,276 @@
+"""Build script for libmdr-bt (also the setuptools entry point).
+
+The CMake build helpers that previously lived in a separate ``cmake_build.py``
+are inlined here. Like that module, this is build-time code and is NOT packaged
+into the wheel; it runs only during ``build_py`` / ``editable_wheel`` to compile
+and stage the native shared library into the package's ``_native`` directory.
+
+C++ source resolution order:
+  1. ``MDR_SOURCE_DIR`` env var            (explicit override)
+  2. ``<repo>/cpp``                        (git submodule, preferred)
+  3. ``<repo>/build/cpp-src``              (shallow fetch of ``_SOURCE_COMMIT`` on every build)
+
+The third option lets ``pip install .`` / ``python -m build`` work from a
+plain source checkout or sdist without the caller having to run
+``git submodule update --init`` first.
+"""
+
+from __future__ import annotations
+
+import configparser
+import os
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from setuptools import Distribution, setup
+from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel
+from setuptools.command.build_py import build_py as _build_py
+from setuptools.command.editable_wheel import editable_wheel as _editable_wheel
+
+# Python repo root (this file lives in <repo>/<pkg>/setup.py).
+_PY_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_BUILD_DIR = _PY_ROOT / "build" / "python"
+# Fresh C++ source clone location (separate from the CMake build dir so the
+# build dir can be wiped between builds without discarding the clone).
+_CLONE_DIR = _PY_ROOT / "build" / "cpp-src"
+# Preferred on-disk location of the C++ sources.
+_SUBMODULE_DIR = _PY_ROOT / "cpp"
+# Upstream coordinates, used only when fetching on demand. The URL is
+# overridden by .gitmodules when present. Upstream has no releases yet, so the
+# sources are pinned to a commit matching the generated bindings.
+_SOURCE_URL = "https://github.com/mos9527/SonyHeadphonesClient.git"
+_SOURCE_COMMIT = "2edf09098db27642c89e533bf86c0a6b162f6ad4"
+
+# CMake target -> on-disk base name (OUTPUT_NAME set in the C++ CMakeLists).
+_TARGET_BASENAMES = {
+    "mdr_shared": "mdr-shared",
+    "mdr-bt_shared": "mdr-bt-shared",
+}
+_SUFFIXES = (".dll", ".so", ".dylib")
+
+
+def _cmake() -> str:
+    env = os.environ.get("CMAKE")
+    if env:
+        return env
+    found = shutil.which("cmake")
+    if found:
+        return found
+    raise RuntimeError("cmake not found on PATH; install CMake or set CMAKE.")
+
+
+def _run(cmd: list[str]) -> None:
+    print("+", " ".join(cmd), flush=True)
+    subprocess.check_call(cmd)
+
+
+def _read_gitmodules() -> str | None:
+    """Return the url of the 'cpp' submodule from .gitmodules, if present."""
+    gm = _PY_ROOT / ".gitmodules"
+    if not gm.is_file():
+        return None
+    cp = configparser.ConfigParser()
+    cp.read(gm, encoding="utf-8")
+    for section in cp.sections():
+        if cp.has_option(section, "path") and cp.get(section, "path") == "cpp":
+            return cp.get(section, "url", fallback=_SOURCE_URL)
+    return None
+
+
+def _rmtree(path: Path) -> None:
+    """Remove a directory tree, tolerating read-only files (git marks .git
+    objects read-only on Windows) and transient file locks."""
+    if not path.exists():
+        return
+
+    def _clear_ro(func, p, exc):  # noqa: ANN001
+        try:
+            os.chmod(p, stat.S_IWRITE)
+            func(p)
+        except OSError:
+            raise
+
+    last_err: OSError | None = None
+    for _ in range(3):
+        try:
+            if sys.version_info >= (3, 12):
+                shutil.rmtree(path, onexc=_clear_ro)
+            else:
+                shutil.rmtree(path, onerror=_clear_ro)
+            return
+        except OSError as exc:
+            last_err = exc
+            time.sleep(0.5)
+    if last_err:
+        raise last_err
+
+
+def _clone_source(dest: Path) -> None:
+    url = _read_gitmodules() or _SOURCE_URL
+    _rmtree(dest)
+    dest.mkdir(parents=True, exist_ok=True)
+    _run(["git", "-C", str(dest), "init", "-q"])
+    _run(["git", "-C", str(dest), "fetch", "--depth", "1", url, _SOURCE_COMMIT])
+    _run(["git", "-C", str(dest), "checkout", "-q", "FETCH_HEAD"])
+
+
+def _ensure_source() -> Path:
+    """Resolve the C++ source directory, cloning it into the build dir if needed."""
+    override = os.environ.get("MDR_SOURCE_DIR")
+    if override:
+        return Path(override)
+    if _SUBMODULE_DIR.is_dir() and any(_SUBMODULE_DIR.iterdir()):
+        return _SUBMODULE_DIR
+    clone_dir = _CLONE_DIR
+    print(f"cpp source not found at {_SUBMODULE_DIR}; fetching {_SOURCE_COMMIT} into {clone_dir}", flush=True)
+    _clone_source(clone_dir)
+    return clone_dir
+
+
+def _config() -> str:
+    return os.environ.get("MDR_CMAKE_CONFIG", "MinSizeRel")
+
+
+def _platform_args() -> list[str]:
+    args: list[str] = []
+    if sys.platform == "darwin":
+        # PEP 517 frontends / cibuildwheel request the target architecture(s)
+        # via ARCHFLAGS (e.g. "-arch x86_64"), which CMake does not read.
+        archs = re.findall(r"-arch\s+(\S+)", os.environ.get("ARCHFLAGS", ""))
+        if archs:
+            args.append("-DCMAKE_OSX_ARCHITECTURES=" + ";".join(archs))
+    return args
+
+
+def _configure(build_dir: Path | None = None, *, config: str | None = None, extra_args: list[str] | None = None) -> Path:
+    build_dir = Path(build_dir or os.environ.get("MDR_PYTHON_BUILD_DIR", DEFAULT_BUILD_DIR))
+    # Always start from a clean build dir so a stale CMake cache or an
+    # interrupted dependency fetch (e.g. fmt via FetchContent) cannot poison
+    # the next configure. The C++ source is re-cloned separately each time.
+    _rmtree(build_dir)
+    build_dir.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        _cmake(), "-S", str(_ensure_source()), "-B", str(build_dir),
+        # Single-config generators (Makefiles/Ninja) ignore `--build --config`.
+        f"-DCMAKE_BUILD_TYPE={config or _config()}",
+        "-DMDR_BUILD_TESTING=OFF",
+        "-DMDR_BUILD_CLIENT=OFF",
+        "-DMDR_BUILD_CODEGEN=OFF",
+        "-DMDR_CLIENT_DEBUGGER=OFF",
+        "-DMDR_ENABLE_LOG=OFF",
+    ]
+    cmd.extend(_platform_args())
+    if extra_args:
+        cmd.extend(extra_args)
+    gen = os.environ.get("MDR_CMAKE_GENERATOR")
+    if gen:
+        cmd[1:1] = ["-G", gen]
+    _run(cmd)
+    return build_dir
+
+
+def _build(targets: list[str], build_dir: Path | None = None, *, config: str | None = None, extra_args: list[str] | None = None) -> Path:
+    config = config or _config()
+    build_dir = _configure(build_dir, config=config, extra_args=extra_args)
+    cmd = [_cmake(), "--build", str(build_dir), "--config", config, "--parallel"]
+    for target in targets:
+        cmd.extend(["--target", target])
+    _run(cmd)
+    return build_dir
+
+
+def _find_built(destination: Path, target: str) -> Path:
+    base = _TARGET_BASENAMES[target]
+    names = {f"{base}{suf}" for suf in _SUFFIXES}
+    names |= {f"lib{base}{suf}" for suf in (".so", ".dylib")}
+    for path in destination.rglob("*"):
+        if path.is_file() and path.name in names:
+            return path.resolve()
+    raise FileNotFoundError(
+        f"Built library for {target} not found under {destination}. "
+        f"Looked for: {', '.join(sorted(names))}"
+    )
+
+
+def stage_libraries(targets: list[str], destination: Path) -> list[Path]:
+    """Build the shared targets and emit them (flattened) into `destination`."""
+    destination = Path(destination).resolve()
+    destination.mkdir(parents=True, exist_ok=True)
+    # Build into the default build directory (e.g. build/python/) instead of
+    # redirecting CMake output directly into _native/.  That avoids CMake's
+    # per-config subdir (MinSizeRel/ on MSVC) being discovered as a namespace
+    # package by setuptools.
+    build_dir = _build(targets)
+    staged: list[Path] = []
+    for target in targets:
+        found = _find_built(build_dir, target)
+        final = destination / found.name
+        if found.resolve() != final.resolve():
+            shutil.copy2(found, final)
+        staged.append(final)
+    return staged
+
+
+def stage_library(target: str, destination: Path) -> Path:
+    """Build one shared target and emit it (flattened) into `destination`."""
+    return stage_libraries([target], destination)[0]
+
+
+def _stage_native() -> None:
+    destination = Path(__file__).resolve().parent / "src" / "libmdr_bt" / "_native"
+    # libmdr-bt links the core statically (PRIVATE mdr), so mdr-bt-shared is
+    # self-contained; the core mdr-shared is provided by the libmdr dependency.
+    stage_libraries(["mdr-bt_shared"], destination)
+
+
+class build_py(_build_py):
+    def run(self) -> None:
+        _stage_native()
+        super().run()
+
+
+class BinaryDistribution(Distribution):
+    """Mark the distribution as platform specific.
+
+    There are no ext_modules (the native library is package data), so without
+    this the wheel is pure and installs into purelib, which auditwheel rejects.
+    """
+
+    def has_ext_modules(self) -> bool:
+        return True
+
+
+class bdist_wheel(_bdist_wheel):
+    """Tag wheels ``py3-none-<platform>``.
+
+    The native library is loaded through ctypes and has no CPython ABI
+    dependency, so a single wheel per platform serves every Python 3
+    interpreter (CPython of any version, free-threaded builds, PyPy).
+    """
+
+    def get_tag(self) -> tuple[str, str, str]:
+        _, _, plat = super().get_tag()
+        return "py3", "none", plat
+
+
+class editable_wheel(_editable_wheel):
+    def run(self) -> None:
+        # build_py.run() (called internally by super()) already handles
+        # the native build via _stage_native().  Calling it here too
+        # would trigger a wasteful second configure+build cycle.
+        super().run()
+
+
+setup(
+    distclass=BinaryDistribution,
+    cmdclass={
+        "bdist_wheel": bdist_wheel,
+        "build_py": build_py,
+        "editable_wheel": editable_wheel,
+    }
+)

libmdr_bt-0.1.0/src/libmdr_bt/__init__.py

@@ -0,0 +1,8 @@
+"""Python bindings for mdr-bt-shared (libmdr-bt)."""
+
+from .connection import PlatformConnection, create_connection
+
+__all__ = [
+    "PlatformConnection",
+    "create_connection",
+]

libmdr_bt-0.1.0/src/libmdr_bt/_dll.py

@@ -0,0 +1,121 @@
+"""ctypes loader for mdr-bt-shared (libmdr-bt)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from ctypes import CDLL
+from pathlib import Path
+
+import libmdr._dll as libmdr_dll
+
+_LIB: CDLL | None = None
+
+_ENV_OVERRIDE = "MDR_BT_DLL"
+
+_CANDIDATE_NAMES = (
+    "mdr-bt-shared.dll",
+    "libmdr-bt-shared.so",
+    "libmdr-bt-shared.dylib",
+    "mdr-bt-shared.so",
+    "mdr-bt-shared.dylib",
+)
+
+_CORE_NAMES = (
+    "mdr-shared.dll",
+    "mdr.dll",
+    "libmdr-shared.so",
+    "libmdr-shared.dylib",
+    "mdr-shared.so",
+    "mdr-shared.dylib",
+)
+
+
+def _package_native_dir() -> Path:
+    return Path(__file__).resolve().parent / "_native"
+
+
+def _candidate_paths() -> list[Path]:
+    paths: list[Path] = []
+    override = os.environ.get(_ENV_OVERRIDE)
+    if override:
+        paths.append(Path(override))
+
+    native = _package_native_dir()
+    for name in _CANDIDATE_NAMES:
+        paths.append(native / name)
+
+    repo_build = Path(__file__).resolve().parents[4] / "build" / "python"
+    if repo_build.is_dir():
+        for name in _CANDIDATE_NAMES:
+            paths.extend(repo_build.rglob(name))
+
+    return paths
+
+
+def _ensure_core_loaded(platform_dir: Path) -> None:
+    if libmdr_dll._LIB is not None:  # noqa: SLF001
+        return
+
+    for name in _CORE_NAMES:
+        sibling = platform_dir / name
+        if sibling.is_file():
+            libmdr_dll._LIB = libmdr_dll._load_path(sibling)  # noqa: SLF001
+            return
+
+    libmdr_dll.load()
+
+
+def _load_path(path: Path) -> CDLL:
+    path = path.resolve()
+    if not path.is_file():
+        raise FileNotFoundError(path)
+
+    _ensure_core_loaded(path.parent)
+
+    if sys.platform == "win32":
+        os.add_dll_directory(str(path.parent))
+        core_dir = libmdr_dll._package_native_dir()  # noqa: SLF001
+        if core_dir.is_dir():
+            os.add_dll_directory(str(core_dir))
+        return CDLL(str(path))
+
+    mode = os.RTLD_GLOBAL if hasattr(os, "RTLD_GLOBAL") else 0
+    return CDLL(str(path), mode=mode)
+
+
+def load() -> CDLL:
+    global _LIB
+    if _LIB is not None:
+        return _LIB
+
+    errors: list[str] = []
+    seen: set[Path] = set()
+    for candidate in _candidate_paths():
+        try:
+            resolved = candidate.resolve()
+        except OSError as exc:
+            errors.append(f"{candidate}: {exc}")
+            continue
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        try:
+            _LIB = _load_path(resolved)
+            return _LIB
+        except OSError as exc:
+            errors.append(f"{resolved}: {exc}")
+
+    hint = (
+        f"Set {_ENV_OVERRIDE} to the full path of mdr-bt-shared.dll, "
+        f"or `pip install -e libmdr-bt` to build it."
+    )
+    raise FileNotFoundError(
+        "Unable to load mdr-bt-shared.\n"
+        + "\n".join(errors)
+        + ("\n" + hint if errors else hint)
+    )
+
+
+def lib() -> CDLL:
+    return load()

libmdr_bt-0.1.0/src/libmdr_bt/connection.py

@@ -0,0 +1,138 @@
+"""Platform connection factories wrapping mdr-bt-shared (libmdr-bt)."""
+
+from __future__ import annotations
+
+import sys
+from ctypes import c_void_p
+from typing import Literal
+
+from libmdr.connection import Connection
+
+from . import _dll
+
+Backend = Literal["auto", "classic", "ble"]
+
+
+def _bind_factory(create_name: str, get_name: str, destroy_name: str):
+    lib = _dll.lib()
+    create = getattr(lib, create_name)
+    getter = getattr(lib, get_name)
+    destroy = getattr(lib, destroy_name)
+
+    create.restype = c_void_p
+    create.argtypes = []
+    getter.restype = c_void_p
+    getter.argtypes = [c_void_p]
+    destroy.restype = None
+    destroy.argtypes = [c_void_p]
+    return create, getter, destroy
+
+
+class PlatformConnection:
+    """Owns a platform-specific connection object and exposes the MDRConnection vtable."""
+
+    def __init__(self, backend: Backend = "auto") -> None:
+        self._backend = "classic" if backend == "auto" else backend
+        self._owner: c_void_p | None = None
+        self._connection: Connection | None = None
+        self._destroy = None
+        self._create()
+
+    def _factories(self):
+        platform = sys.platform
+        if platform == "win32":
+            if self._backend == "ble":
+                return _bind_factory(
+                    "mdrConnectionWindowsBLECreate",
+                    "mdrConnectionWindowsBLEGet",
+                    "mdrConnectionWindowsBLEDestroy",
+                )
+            return _bind_factory(
+                "mdrConnectionWindowsCreate",
+                "mdrConnectionWindowsGet",
+                "mdrConnectionWindowsDestroy",
+            )
+        if platform == "darwin":
+            if self._backend == "ble":
+                raise RuntimeError("BLE backend is not available on macOS in mdr-bt-shared")
+            return _bind_factory(
+                "mdrConnectionMacOSCreate",
+                "mdrConnectionMacOSGet",
+                "mdrConnectionMacOSDestroy",
+            )
+        if platform.startswith("linux"):
+            if self._backend == "ble":
+                raise RuntimeError("BLE backend is not available on Linux in mdr-bt-shared")
+            return _bind_factory(
+                "mdrConnectionLinuxCreate",
+                "mdrConnectionLinuxGet",
+                "mdrConnectionLinuxDestroy",
+            )
+        raise RuntimeError(f"Unsupported platform for libmdr-bt bindings: {platform}")
+
+    def _create(self) -> None:
+        create, getter, destroy = self._factories()
+        owner = create()
+        if not owner:
+            raise RuntimeError(f"Failed to create platform connection ({self._backend})")
+        connection = getter(owner)
+        if not connection:
+            destroy(owner)
+            raise RuntimeError("Platform connection Get() returned null")
+
+        self._destroy = destroy
+        self._owner = c_void_p(owner)
+        self._connection = Connection(connection)
+
+    @property
+    def backend(self) -> str:
+        return self._backend
+
+    @property
+    def connection(self) -> Connection:
+        if self._connection is None:
+            raise RuntimeError("Platform connection is closed")
+        return self._connection
+
+    def close(self) -> None:
+        if self._owner is not None and self._destroy is not None:
+            self._destroy(self._owner)
+            self._owner = None
+            self._connection = None
+
+    def __enter__(self) -> PlatformConnection:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    def devices(self):
+        return self.connection.devices()
+
+    def connect(self, mac_address: str, service_uuid: str) -> int:
+        return self.connection.connect(mac_address, service_uuid)
+
+    def disconnect(self) -> None:
+        self.connection.disconnect()
+
+    def poll(self, timeout_ms: int = 0) -> int:
+        return self.connection.poll(timeout_ms)
+
+    def last_error(self) -> str:
+        return self.connection.last_error()
+
+
+def create_connection(*, ble: bool = False, backend: Backend | None = None) -> PlatformConnection:
+    """Create the host platform connection.
+
+    Prefer `ble=True` / `backend="ble"` on Windows when talking over GATT.
+    """
+    if backend is None:
+        backend = "ble" if ble else "classic"
+    return PlatformConnection(backend=backend)

libmdr_bt-0.1.0/src/libmdr_bt.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: libmdr-bt
+Version: 0.1.0
+Summary: Python binding for libmdr-bt (Sony headphones platform connection backend)
+License-Expression: MIT
+Project-URL: Source, https://github.com/mos9527/libmdr-py
+Requires-Python: >=3.10
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: libmdr
+Dynamic: license-file
+
+ctypes bindings for libmdr-bt (mdr-bt-shared).

libmdr_bt-0.1.0/src/libmdr_bt.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/libmdr_bt/__init__.py
+src/libmdr_bt/_dll.py
+src/libmdr_bt/connection.py
+src/libmdr_bt.egg-info/PKG-INFO
+src/libmdr_bt.egg-info/SOURCES.txt
+src/libmdr_bt.egg-info/dependency_links.txt
+src/libmdr_bt.egg-info/requires.txt
+src/libmdr_bt.egg-info/top_level.txt

libmdr_bt-0.1.0/src/libmdr_bt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

libmdr_bt-0.1.0/src/libmdr_bt.egg-info/requires.txt

@@ -0,0 +1 @@
+libmdr

libmdr_bt-0.1.0/src/libmdr_bt.egg-info/top_level.txt

@@ -0,0 +1 @@
+libmdr_bt