libmdr 0.1.0__tar.gz

libmdr-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-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: libmdr
+Version: 0.1.0
+Summary: Python bindings for the mdr-shared C ABI
+License-Expression: MIT
+Project-URL: Source, https://github.com/mos9527/libmdr-py
+Requires-Python: >=3.10
+Description-Content-Type: text/plain
+License-File: LICENSE
+Provides-Extra: dev
+Provides-Extra: bt
+Requires-Dist: libmdr-bt; extra == "bt"
+Provides-Extra: cli
+Requires-Dist: libmdr-cli; extra == "cli"
+Dynamic: license-file
+
+ctypes bindings for libmdr (mdr-shared).

libmdr-0.1.0/README.md

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

libmdr-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "libmdr"
+version = "0.1.0"
+description = "Python bindings for the mdr-shared C ABI"
+readme = { text = "ctypes bindings for libmdr (mdr-shared).", content-type = "text/plain" }
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+
+[project.optional-dependencies]
+dev = []
+bt = ["libmdr-bt"]
+cli = ["libmdr-cli"]
+
+[project.urls]
+Source = "https://github.com/mos9527/libmdr-py"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+libmdr = ["_native/*"]
+
+# Wheels are tagged py3-none-<platform> (see setup.py): the native library is
+# loaded via ctypes, so it is built once per platform and cibuildwheel reuses
+# that wheel to run the tests on every other selected interpreter.
+[tool.cibuildwheel]
+skip = ["*-musllinux_*", "cp31[1-9]*-manylinux_armv7l"]  # armv7l runs under QEMU: test once
+build-verbosity = 1
+test-command = "python -c \"import libmdr, libmdr._dll as d; print(d.load())\""
+# Ubuntu 22.04 based; manylinux_2_31 (Ubuntu 20.04) defaults to GCC 9, without <span>.
+# The resulting wheels still only need glibc 2.17: auditwheel tags them accordingly.
+manylinux-armv7l-image = "manylinux_2_35"
+
+[tool.cibuildwheel.linux]
+before-all = "sh {project}/tooling/ci/linux-before-all.sh"
+
+[tool.cibuildwheel.macos]
+environment = { MACOSX_DEPLOYMENT_TARGET = "12.0" }
+
+[tool.cibuildwheel.windows]
+# No Python extension modules; mdr-shared.dll links the CRT statically.
+repair-wheel-command = ""

libmdr-0.1.0/setup.cfg

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

libmdr-0.1.0/setup.py

@@ -0,0 +1,283 @@
+"""Build script for libmdr (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
+from setuptools.command.sdist import sdist as _sdist
+
+# 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_BT=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" / "_native"
+    stage_library("mdr_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()
+
+
+class sdist(_sdist):
+    def run(self) -> None:
+        # Source distributions do not embed platform binaries.
+        super().run()
+
+
+setup(
+    distclass=BinaryDistribution,
+    cmdclass={
+        "bdist_wheel": bdist_wheel,
+        "build_py": build_py,
+        "editable_wheel": editable_wheel,
+        "sdist": sdist,
+    }
+)

libmdr-0.1.0/src/libmdr/__init__.py

@@ -0,0 +1,18 @@
+"""Python bindings for libmdr (mdr-shared C ABI)."""
+
+from . import constants, result
+from .connection import Connection, DeviceInfo
+from .headphones import Headphones
+from .result import ABI_VERSION, MDRError, check, result_string
+
+__all__ = [
+    "ABI_VERSION",
+    "Connection",
+    "DeviceInfo",
+    "Headphones",
+    "MDRError",
+    "check",
+    "constants",
+    "result",
+    "result_string",
+]

libmdr-0.1.0/src/libmdr/_api.py

@@ -0,0 +1,10 @@
+"""ctypes structs and prototypes for the mdr-c ABI."""
+
+from __future__ import annotations
+
+from . import _dll
+from ._generated_api import *  # noqa: F403
+from ._generated_api import bind as _bind
+
+
+_bind(_dll.lib())

libmdr-0.1.0/src/libmdr/_dll.py

@@ -0,0 +1,92 @@
+"""ctypes loader for mdr-shared."""
+
+from __future__ import annotations
+
+import os
+import sys
+from ctypes import CDLL, RTLD_GLOBAL
+from pathlib import Path
+
+_LIB: CDLL | None = None
+
+_ENV_OVERRIDE = "MDR_DLL"
+
+_CANDIDATE_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)
+
+    # Editable / in-tree builds may leave artifacts in the shared CMake tree.
+    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 _load_path(path: Path) -> CDLL:
+    path = path.resolve()
+    if not path.is_file():
+        raise FileNotFoundError(path)
+
+    if sys.platform == "win32":
+        os.add_dll_directory(str(path.parent))
+        return CDLL(str(path))
+
+    mode = 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-shared "
+        f"(or mdr.dll), or `pip install -e libmdr` to build it."
+    )
+    raise FileNotFoundError(
+        "Unable to load mdr-shared.\n" + "\n".join(errors) + ("\n" + hint if errors else hint)
+    )
+
+
+def lib() -> CDLL:
+    return load()