pytest-embedded-arduino-cli 0.2.0__py3-none-any.whl

pytest_embedded_arduino_cli/__init__.py

@@ -0,0 +1,6 @@
+"""pytest-embedded integration for Arduino CLI based projects."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.2.0"
+

pytest_embedded_arduino_cli/app.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import subprocess
+import os
+import tomllib
+from typing import Any
+
+import yaml
+
+
+class SketchConfigError(ValueError):
+    """Raised when the sketch directory or sketch.yaml is invalid."""
+
+
+def resolve_test_path(raw_path: str | Path) -> Path:
+    path = Path(raw_path).resolve()
+    if path.is_dir():
+        return path
+    return path.parent
+
+
+def resolve_sketch_dir(test_file_or_dir: str | Path) -> Path:
+    sketch_dir = resolve_test_path(test_file_or_dir)
+    ino_files = sorted(sketch_dir.glob("*.ino"))
+    if not ino_files:
+        raise SketchConfigError(f"no .ino file found in sketch directory: {sketch_dir}")
+    if len(ino_files) > 1:
+        raise SketchConfigError(
+            f"multiple .ino files found in sketch directory: {sketch_dir}. "
+            "Keep one sketch per test directory."
+        )
+    return sketch_dir
+
+
+def find_sketch_yaml(sketch_dir: str | Path) -> Path:
+    current = Path(sketch_dir).resolve()
+    for candidate_dir in (current, *current.parents):
+        candidate = candidate_dir / "sketch.yaml"
+        if candidate.is_file():
+            return candidate
+    raise SketchConfigError(f"sketch.yaml not found from sketch directory: {current}")
+
+
+def load_sketch_yaml(path: str | Path) -> dict[str, Any]:
+    config_path = Path(path)
+    with config_path.open("r", encoding="utf-8") as handle:
+        data = yaml.safe_load(handle) or {}
+
+    if not isinstance(data, dict):
+        raise SketchConfigError(f"sketch.yaml must contain a mapping: {config_path}")
+
+    profiles = data.get("profiles", {})
+    if profiles is not None and not isinstance(profiles, dict):
+        raise SketchConfigError(f"'profiles' must be a mapping in {config_path}")
+
+    return data
+
+
+def resolve_profile_name(sketch_data: dict[str, Any], profile: str | None) -> str | None:
+    profiles = sketch_data.get("profiles") or {}
+    if profile:
+        if profiles and profile not in profiles:
+            raise SketchConfigError(f"profile '{profile}' not found in sketch.yaml")
+        return profile
+
+    default_profile = sketch_data.get("default_profile")
+    if default_profile is not None and not isinstance(default_profile, str):
+        raise SketchConfigError("'default_profile' in sketch.yaml must be a string")
+
+    if default_profile:
+        return default_profile
+
+    if len(profiles) == 1:
+        return next(iter(profiles))
+
+    if len(profiles) > 1:
+        raise SketchConfigError(
+            "multiple profiles found in sketch.yaml; "
+            "specify --profile or set default_profile"
+        )
+
+    return None
+
+
+def resolve_build_path(sketch_dir: str | Path, profile: str | None, build_path: str | Path | None = None) -> Path:
+    if build_path:
+        return Path(build_path).resolve()
+
+    suffix = profile or "default"
+    return Path(sketch_dir).resolve() / "build" / suffix
+
+
+def load_build_config(sketch_dir: str | Path) -> dict[str, Any]:
+    config_path = Path(sketch_dir).resolve() / "build_config.toml"
+    if not config_path.is_file():
+        return {}
+
+    with config_path.open("rb") as handle:
+        data = tomllib.load(handle)
+
+    if not isinstance(data, dict):
+        raise SketchConfigError(f"build_config.toml must contain a mapping: {config_path}")
+
+    defines = data.get("defines", {})
+    if defines is not None and not isinstance(defines, dict):
+        raise SketchConfigError(f"'defines' must be a mapping in {config_path}")
+
+    return data
+
+
+def _format_define_value(value: str) -> str:
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def resolve_build_properties(
+    sketch_dir: str | Path,
+    build_config: dict[str, Any] | None = None,
+) -> tuple[str, ...]:
+    config = build_config if build_config is not None else load_build_config(sketch_dir)
+    defines = config.get("defines") or {}
+    extra_flags: list[str] = []
+
+    for env_name, define_name in defines.items():
+        if not isinstance(env_name, str) or not isinstance(define_name, str):
+            raise SketchConfigError("build_config.toml defines keys and values must be strings")
+
+        value = os.getenv(env_name, "")
+        extra_flags.append(f"-D{define_name}={_format_define_value(value)}")
+
+    if not extra_flags:
+        return ()
+
+    return (f"build.extra_flags={' '.join(extra_flags)}",)
+
+
+@dataclass(frozen=True)
+class ArduinoCliBuildConfig:
+    sketch_dir: Path
+    sketch_yaml: Path
+    build_path: Path
+    profile: str | None = None
+    build_properties: tuple[str, ...] = field(default_factory=tuple)
+    extra_args: tuple[str, ...] = field(default_factory=tuple)
+    clean: bool = False
+    cli_path: str = "arduino-cli"
+
+    @classmethod
+    def from_test_path(
+        cls,
+        test_file_or_dir: str | Path,
+        *,
+        profile: str | None = None,
+        build_path: str | Path | None = None,
+        build_properties: tuple[str, ...] = (),
+        extra_args: tuple[str, ...] = (),
+        clean: bool = False,
+        cli_path: str = "arduino-cli",
+    ) -> "ArduinoCliBuildConfig":
+        sketch_dir = resolve_sketch_dir(test_file_or_dir)
+        sketch_yaml = find_sketch_yaml(sketch_dir)
+        sketch_data = load_sketch_yaml(sketch_yaml)
+        build_config = load_build_config(sketch_dir)
+        resolved_profile = resolve_profile_name(sketch_data, profile)
+        resolved_build_path = resolve_build_path(sketch_dir, resolved_profile, build_path)
+        resolved_build_properties = tuple(build_properties) + resolve_build_properties(sketch_dir, build_config)
+        return cls(
+            sketch_dir=sketch_dir,
+            sketch_yaml=sketch_yaml,
+            build_path=resolved_build_path,
+            profile=resolved_profile,
+            build_properties=resolved_build_properties,
+            extra_args=tuple(extra_args),
+            clean=clean,
+            cli_path=cli_path,
+        )
+
+    def build_command(self) -> list[str]:
+        command = [self.cli_path, "compile", "--build-path", str(self.build_path)]
+        if self.clean:
+            command.append("--clean")
+        if self.profile:
+            command.extend(["--profile", self.profile])
+        for build_property in self.build_properties:
+            command.extend(["--build-property", build_property])
+        command.extend(self.extra_args)
+        command.append(str(self.sketch_dir))
+        return command
+
+    def compile(self, *, check: bool = True) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            self.build_command(),
+            check=check,
+            cwd=self.sketch_dir,
+            text=True,
+        )

pytest_embedded_arduino_cli/flasher.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import subprocess
+
+from .app import ArduinoCliBuildConfig
+
+
+@dataclass(frozen=True)
+class ArduinoCliUploadConfig:
+    sketch_dir: Path
+    build_path: Path
+    profile: str | None = None
+    port: str | None = None
+    extra_args: tuple[str, ...] = field(default_factory=tuple)
+    cli_path: str = "arduino-cli"
+
+    @classmethod
+    def from_build_config(
+        cls,
+        build_config: ArduinoCliBuildConfig,
+        *,
+        port: str | None = None,
+        extra_args: tuple[str, ...] = (),
+        cli_path: str | None = None,
+    ) -> "ArduinoCliUploadConfig":
+        return cls(
+            sketch_dir=build_config.sketch_dir,
+            build_path=build_config.build_path,
+            profile=build_config.profile,
+            port=port,
+            extra_args=tuple(extra_args),
+            cli_path=cli_path or build_config.cli_path,
+        )
+
+    def upload_command(self) -> list[str]:
+        command = [self.cli_path, "upload", "--build-path", str(self.build_path)]
+        if self.profile:
+            command.extend(["--profile", self.profile])
+        if self.port:
+            command.extend(["--port", self.port])
+        command.extend(self.extra_args)
+        command.append(str(self.sketch_dir))
+        return command
+
+    def upload(self, *, check: bool = True) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            self.upload_command(),
+            check=check,
+            cwd=self.sketch_dir,
+            text=True,
+        )
+

pytest_embedded_arduino_cli/plugin.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from pathlib import Path
+import shlex
+from typing import Any
+
+import pytest
+
+from .app import ArduinoCliBuildConfig, SketchConfigError, resolve_sketch_dir, resolve_test_path
+from .flasher import ArduinoCliUploadConfig
+from .serial import ensure_default_embedded_services, resolve_port, resolve_upload_port
+
+
+def _should_build(run_mode: str) -> bool:
+    return run_mode in ("all", "build")
+
+
+def _should_upload(run_mode: str) -> bool:
+    return run_mode in ("all", "test")
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("arduino-cli")
+    group.addoption(
+        "--run-mode",
+        action="store",
+        choices=("all", "build", "test"),
+        default="all",
+        help="Select whether to run build only, upload-and-test with existing artifacts, or build-upload-test.",
+    )
+    group.addoption(
+        "--profile",
+        action="store",
+        help="Arduino CLI sketch profile name from sketch.yaml.",
+    )
+
+
+def pytest_report_header(config: pytest.Config) -> list[str]:
+    return [
+        f"arduino-cli run-mode: {config.getoption('run_mode')}",
+        f"arduino-cli profile: {config.getoption('profile') or 'default'}",
+    ]
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    ensure_default_embedded_services(config)
+
+
+def _request_path(request: pytest.FixtureRequest) -> Path:
+    if hasattr(request, "path"):
+        return Path(request.path)
+    return Path(str(request.fspath))
+
+
+def _request_has_sketch(request: pytest.FixtureRequest) -> bool:
+    test_path = resolve_test_path(_request_path(request))
+    return any(test_path.glob("*.ino"))
+
+
+def _terminal_reporter(config: pytest.Config) -> Any | None:
+    return config.pluginmanager.getplugin("terminalreporter")
+
+
+def _verbose_level(config: pytest.Config) -> int:
+    return int(getattr(config.option, "verbose", 0) or 0)
+
+
+def _log_command(
+    config: pytest.Config,
+    *,
+    action: str,
+    command: list[str],
+    details: dict[str, str | None],
+) -> None:
+    verbosity = _verbose_level(config)
+    if verbosity < 1:
+        return
+
+    reporter = _terminal_reporter(config)
+    if reporter is None:
+        return
+
+    reporter.write_line(f"[arduino-cli] {action}: {shlex.join(command)}")
+    if verbosity < 2:
+        return
+
+    for key, value in details.items():
+        if value is None:
+            continue
+        reporter.write_line(f"[arduino-cli] {action} {key}: {value}")
+
+
+@pytest.fixture
+def app_path(request: pytest.FixtureRequest) -> str:
+    if not _request_has_sketch(request):
+        return str(resolve_test_path(_request_path(request)))
+    return str(resolve_sketch_dir(_request_path(request)))
+
+
+@pytest.fixture
+def build_dir(request: pytest.FixtureRequest) -> str:
+    arduino_cli_app = _build_config_from_request(request, required=False)
+    if arduino_cli_app is None:
+        return str(resolve_test_path(_request_path(request)) / "build" / "default")
+    return str(arduino_cli_app.build_path)
+
+
+@pytest.fixture
+def skip_autoflash() -> bool:
+    # Build/upload are handled explicitly by this plugin instead of pytest-embedded services.
+    return True
+
+
+def _build_config_from_request(
+    request: pytest.FixtureRequest,
+    *,
+    required: bool = True,
+) -> ArduinoCliBuildConfig | None:
+    config = request.config
+    should_require = required or _request_has_sketch(request)
+    try:
+        return ArduinoCliBuildConfig.from_test_path(
+            _request_path(request),
+            profile=config.getoption("profile"),
+        )
+    except SketchConfigError:
+        if should_require:
+            raise
+        return None
+
+
+@pytest.fixture(scope="module")
+def arduino_cli_app(request: pytest.FixtureRequest) -> ArduinoCliBuildConfig:
+    return _build_config_from_request(request)
+
+
+@pytest.fixture(scope="module")
+def arduino_cli_flasher(
+    request: pytest.FixtureRequest,
+    arduino_cli_app: ArduinoCliBuildConfig,
+) -> ArduinoCliUploadConfig:
+    return ArduinoCliUploadConfig.from_build_config(
+        arduino_cli_app,
+        port=resolve_upload_port(request.config, profile=arduino_cli_app.profile),
+    )
+
+
+@pytest.fixture(scope="module", autouse=True)
+def arduino_cli_resolved_port(request: pytest.FixtureRequest) -> None:
+    arduino_cli_app = _build_config_from_request(request, required=False)
+    if arduino_cli_app is None:
+        return
+
+    if getattr(request.config.option, "flash_port", None):
+        return
+    if getattr(request.config.option, "port", None):
+        return
+
+    resolved_port = resolve_port(request.config, profile=arduino_cli_app.profile)
+    if resolved_port:
+        request.config.option.port = resolved_port
+
+
+@pytest.fixture(scope="module", autouse=True)
+def arduino_cli_build(
+    request: pytest.FixtureRequest,
+    arduino_cli_resolved_port: None,
+) -> None:
+    arduino_cli_app = _build_config_from_request(request, required=False)
+    if arduino_cli_app is None:
+        return
+    if not _should_build(request.config.getoption("run_mode")):
+        return
+
+    _log_command(
+        request.config,
+        action="compile",
+        command=arduino_cli_app.build_command(),
+        details={
+            "cwd": str(arduino_cli_app.sketch_dir),
+            "sketch_dir": str(arduino_cli_app.sketch_dir),
+            "build_path": str(arduino_cli_app.build_path),
+            "profile": arduino_cli_app.profile,
+        },
+    )
+    arduino_cli_app.compile()
+
+
+@pytest.fixture(scope="module", autouse=True)
+def arduino_cli_upload(
+    request: pytest.FixtureRequest,
+    arduino_cli_build: None,
+    arduino_cli_resolved_port: None,
+) -> None:
+    run_mode = request.config.getoption("run_mode")
+    if not _should_upload(run_mode):
+        return
+    arduino_cli_app = _build_config_from_request(request, required=False)
+    if arduino_cli_app is None:
+        return
+    if not arduino_cli_app.build_path.is_dir():
+        raise FileNotFoundError(
+            f"build output directory not found: {arduino_cli_app.build_path}. "
+            "Run with --run-mode=all first, or build the sketch before --run-mode=test."
+        )
+
+    arduino_cli_flasher = ArduinoCliUploadConfig.from_build_config(
+        arduino_cli_app,
+        port=resolve_upload_port(request.config, profile=arduino_cli_app.profile),
+    )
+
+    _log_command(
+        request.config,
+        action="upload",
+        command=arduino_cli_flasher.upload_command(),
+        details={
+            "cwd": str(arduino_cli_flasher.sketch_dir),
+            "sketch_dir": str(arduino_cli_flasher.sketch_dir),
+            "build_path": str(arduino_cli_flasher.build_path),
+            "profile": arduino_cli_flasher.profile,
+            "port": arduino_cli_flasher.port,
+        },
+    )
+    arduino_cli_flasher.upload()
+
+
+@pytest.fixture(autouse=True)
+def skip_test_execution_in_build_mode(
+    request: pytest.FixtureRequest,
+    arduino_cli_build: None,
+) -> None:
+    if request.config.getoption("run_mode") == "build":
+        pytest.skip("skipped test execution in build-only mode")

pytest_embedded_arduino_cli/serial.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from _pytest.config import Config
+import os
+
+
+def normalize_profile_name(profile: str) -> str:
+    return profile.upper().replace("-", "_")
+
+
+def ensure_default_embedded_services(config: Config) -> None:
+    current = getattr(config.option, "embedded_services", None)
+    if not current:
+        config.option.embedded_services = "serial"
+        return
+
+    services = [service.strip() for service in current.split(",") if service.strip()]
+    if "serial" in services:
+        return
+
+    services.append("serial")
+    config.option.embedded_services = ",".join(services)
+
+
+def resolve_port(config: Config, profile: str | None = None) -> str | None:
+    flash_port = getattr(config.option, "flash_port", None)
+    if flash_port:
+        return flash_port
+
+    port = getattr(config.option, "port", None)
+    if port:
+        return port
+
+    if profile is None:
+        profile = getattr(config.option, "profile", None)
+
+    if profile:
+        profile_port = os.getenv(f"TEST_SERIAL_PORT_{normalize_profile_name(profile)}")
+        if profile_port:
+            return profile_port
+
+    return os.getenv("TEST_SERIAL_PORT")
+
+
+def resolve_upload_port(config: Config, profile: str | None = None) -> str | None:
+    return resolve_port(config, profile=profile)

pytest_embedded_arduino_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: pytest-embedded-arduino-cli
+Version: 0.2.0
+Summary: A pytest plugin to test Arduino projects using pytest-embedded and arduino-cli
+Project-URL: Homepage, https://github.com/tanakamasayuki/pytest-embedded-arduino-cli
+Project-URL: Repository, https://github.com/tanakamasayuki/pytest-embedded-arduino-cli
+Author: TANAKA Masayuki
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: pytest-embedded-serial>=2.0
+Requires-Dist: pytest-embedded>=2.0
+Requires-Dist: pytest>=8
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# pytest-embedded-arduino-cli
+
+[日本語版 README](README.ja.md)
+
+A pytest plugin to test Arduino projects using `pytest-embedded` and `arduino-cli`.
+
+## Overview
+
+`pytest-embedded-arduino-cli` is a small plugin that keeps `pytest-embedded`'s generic DUT / serial / expect flow and replaces Arduino-specific build and upload with `arduino-cli`.
+
+This package does not depend on `pytest-embedded-arduino`. It is intended to stay generic enough to work well for Arduino projects beyond ESP32-specific assumptions.
+
+## Design
+
+- Build with `arduino-cli compile`
+- Upload with `arduino-cli upload`
+- Use `pytest-embedded` as the runtime foundation
+- Avoid `EspSerial` and ESP-specific flashing services
+- Resolve sketch settings from `sketch.yaml` and `--profile`
+- Treat the test file directory as the sketch directory
+
+## Setup
+
+```bash
+uv init
+uv add pytest-embedded-arduino-cli
+uv sync
+```
+
+Runtime dependencies include:
+
+- `pytest`
+- `pytest-embedded`
+- `pytest-embedded-serial`
+- `PyYAML`
+
+## Requirements
+
+- `arduino-cli` available in `PATH`
+- Installed Arduino board core(s)
+- A serial port accessible from the host when running hardware tests
+
+## Project Layout
+
+The expected layout is one sketch directory per test app.
+
+```text
+tests/
+  my_app/
+    sketch.yaml
+    my_app.ino
+    test_my_app.py
+```
+
+When pytest runs a specific `.py` file, this plugin treats that file's directory as the sketch directory. Build settings are resolved from the nearest `sketch.yaml`.
+
+## Usage
+
+Build, upload, and run tests:
+
+```bash
+uv run pytest tests/my_app --port /dev/ttyACM0
+```
+
+Select an Arduino CLI profile from `sketch.yaml`:
+
+```bash
+uv run pytest tests/my_app --profile esp32s3 --port /dev/ttyACM0
+```
+
+Build only:
+
+```bash
+uv run pytest tests/my_app --run-mode=build
+```
+
+Upload and test against an already-built image:
+
+```bash
+uv run pytest tests/my_app --run-mode=test --port /dev/ttyACM0
+```
+
+`--run-mode=test` skips compile, reuses the existing build output, uploads it, and then runs the test.
+
+Run this package's own tests:
+
+```bash
+uv run pytest
+```
+
+## Main Options
+
+- `--run-mode=all|build|test`
+- `--profile`
+
+Use `pytest-embedded` standard options for runtime control, such as:
+
+- `--port`
+- `--flash-port`
+- `--baud`
+- `--embedded-services`
+
+`pytest-embedded-serial` is installed as a normal dependency so hardware tests can use the serial service without extra package installation.
+If `--embedded-services` is not specified, this plugin enables `serial` by default.
+
+For profile-specific serial ports, the plugin resolves ports in this order:
+
+1. `--flash-port`
+2. `--port`
+3. `TEST_SERIAL_PORT_<PROFILE>`
+4. `TEST_SERIAL_PORT`
+
+Example:
+
+```bash
+export TEST_SERIAL_PORT_ESP32S3=/dev/ttyUSB1
+uv run pytest tests/my_app --profile esp32s3
+```
+
+If `--profile` is omitted, the plugin uses the resolved profile from `sketch.yaml`, including `default_profile`.
+
+For compile-time defines, place a `build_config.toml` in the sketch directory:
+
+```toml
+[defines]
+TEST_WIFI_SSID = "WIFI_SSID"
+TEST_WIFI_PASSWORD = "WIFI_PASSWORD"
+```
+
+Here, the left side is the environment variable name and the right side is the C/C++ define name.
+For example, `TEST_WIFI_SSID` becomes `-DWIFI_SSID="..."` at compile time.
+
+Set values before running pytest:
+
+```bash
+export TEST_WIFI_SSID=my-ssid
+export TEST_WIFI_PASSWORD=my-password
+uv run pytest tests/my_app
+```
+
+If an environment variable is missing, the plugin still passes the define with an empty string value.
+This allows the test or sketch code to decide how to handle missing settings.
+
+For command visibility, follow pytest's standard verbosity:
+
+- `-v` shows the `arduino-cli compile` / `arduino-cli upload` command line
+- `-vv` also shows execution context such as `cwd`, `sketch_dir`, `build_path`, `profile`, and `port`
+
+## Example
+
+```python
+def test_hello(dut):
+    dut.expect_exact("hello from arduino")
+```
+
+```cpp
+void setup() {
+  Serial.begin(115200);
+  delay(1000);
+  Serial.println("hello from arduino");
+}
+
+void loop() {}
+```
+
+Additional sample:
+
+- `examples/wifi`
+  - Connects to Wi-Fi on ESP32/ESP32-S3
+  - Includes `uno` as a skip example for a non-Wi-Fi profile
+  - Expects `TEST_WIFI_SSID` and `TEST_WIFI_PASSWORD`
+  - Verifies that the board prints `WIFI_OK <ip-address>`
+
+## What This Plugin Does Not Try To Be
+
+- A drop-in replacement for `pytest-embedded-arduino`
+- An ESP-specific flashing layer
+- A board auto-discovery tool
+
+## Future Extensions
+
+- Board-family-specific upload strategies
+- Smarter artifact discovery
+- Serial reset / monitor helpers
+- Multi-device support
+- Optional `fqbn` or sketch path overrides
+
+## Release
+
+This repository uses GitHub Actions for releases.
+
+Before triggering a release:
+
+- Update the `## Unreleased` section in `CHANGELOG.md`
+- Make sure `uv run pytest tests` passes locally if needed
+
+Release flow:
+
+1. Open GitHub Actions
+2. Run the `Release` workflow manually
+3. Enter the release version such as `0.1.0`
+4. Choose whether to publish to PyPI
+
+The workflow will:
+
+- Update versions in `pyproject.toml` and `src/pytest_embedded_arduino_cli/__init__.py`
+- Move `CHANGELOG.md` unreleased entries into `## <version>`
+- Run tests and build the package
+- Commit the release changes and create tag `v<version>`
+- Create a GitHub Release
+- Publish to PyPI when enabled
+
+PyPI publishing is configured for Trusted Publishing via GitHub Actions.

pytest_embedded_arduino_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pytest_embedded_arduino_cli/__init__.py,sha256=9GeHLG02tvvRQBrOVlat-DYqCljAPCZk58KaLpqxZHk,117
+pytest_embedded_arduino_cli/app.py,sha256=BXfXcDxCzGbblSp2YdDeowWKoaJozB2LYqnLJILeFJ4,6676
+pytest_embedded_arduino_cli/flasher.py,sha256=PBOahJploQXowWEL6G5Eyph7rdpVhnWqt_wiMJbF4nw,1591
+pytest_embedded_arduino_cli/plugin.py,sha256=1vfYPDHebpXxstM-wZf7EwlvCQiwckOnKnUqfkJYBxM,7013
+pytest_embedded_arduino_cli/serial.py,sha256=NMw_5PGBNmwormXEM-hwY1jC58INhnDB4lmp62cieHU,1295
+pytest_embedded_arduino_cli-0.2.0.dist-info/METADATA,sha256=3x2ujSLzSCjKiK-wE7SYSuozH566gWbqXoO4A3-wqbw,5955
+pytest_embedded_arduino_cli-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pytest_embedded_arduino_cli-0.2.0.dist-info/entry_points.txt,sha256=EWR-UiOmXcgVHzTz9aOxfWWXC4hL8XN3wcznjEBi38Q,69
+pytest_embedded_arduino_cli-0.2.0.dist-info/licenses/LICENSE,sha256=VGGOGhKirXWqqgXfW1JW4h5Ekk-5FJ7ybJTeETBpQy4,1072
+pytest_embedded_arduino_cli-0.2.0.dist-info/RECORD,,

pytest_embedded_arduino_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pytest_embedded_arduino_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+embedded-arduino-cli = pytest_embedded_arduino_cli.plugin

pytest_embedded_arduino_cli-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TANAKA Masayuki
+
+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.