Barmaja-PyArduino 2.0.0__py3-none-any.whl

Barmaja_PyArduino/board.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class BoardProfile:
+    id: str
+    name: str
+    fqbn: str
+    mcu: str
+    flash_bytes: int
+    sram_bytes: int
+    digital_pins: tuple[int, ...]
+    analog_aliases: dict[str, int]
+    analog_channels: tuple[int, ...]
+    pwm_pins: tuple[int, ...]
+    pwm_timer_map: dict[int, str]
+    uart_rx_pin: int
+    uart_tx_pin: int
+    i2c_sda_pin: int
+    i2c_scl_pin: int
+    servo_timer: str
+    servo_pwm_conflict_pins: tuple[int, ...]
+    servo_max_channels: int
+    millis_bits: int
+    cpp_int_bits: int
+    float_bits: int
+    sram_warning_ratio: float = 0.75
+    sram_error_ratio: float = 0.90
+
+    @property
+    def analog_pins(self) -> tuple[int, ...]:
+        return tuple(self.analog_aliases.values())
+
+    @property
+    def digital_capable_pins(self) -> tuple[int, ...]:
+        # Arduino AVR core permits A0..A5 aliases to be used as digital pins.
+        return tuple(sorted(set(self.digital_pins) | set(self.analog_pins)))
+
+    @property
+    def uart_pins(self) -> tuple[int, int]:
+        return (self.uart_rx_pin, self.uart_tx_pin)
+
+    @property
+    def i2c_pins(self) -> tuple[int, int]:
+        return (self.i2c_sda_pin, self.i2c_scl_pin)
+
+    def alias_for_pin(self, pin: int) -> str | None:
+        for alias, number in self.analog_aliases.items():
+            if number == pin:
+                return alias
+        return None
+
+
+UNO = BoardProfile(
+    id="uno",
+    name="Arduino Uno",
+    fqbn="arduino:avr:uno",
+    mcu="ATmega328P",
+    flash_bytes=32256,  # usable program space (32 KiB minus the 512-byte Optiboot bootloader)
+    sram_bytes=2048,
+    digital_pins=tuple(range(14)),
+    analog_aliases={f"A{i}": 14 + i for i in range(6)},
+    analog_channels=tuple(range(6)),
+    pwm_pins=(3, 5, 6, 9, 10, 11),
+    pwm_timer_map={3: "Timer2", 5: "Timer0", 6: "Timer0", 9: "Timer1", 10: "Timer1", 11: "Timer2"},
+    uart_rx_pin=0,
+    uart_tx_pin=1,
+    i2c_sda_pin=18,  # A4
+    i2c_scl_pin=19,  # A5
+    servo_timer="Timer1",
+    servo_pwm_conflict_pins=(9, 10),
+    servo_max_channels=12,
+    millis_bits=32,
+    cpp_int_bits=16,
+    float_bits=32,
+)
+
+BOARDS = {UNO.id: UNO, UNO.fqbn: UNO}

Barmaja_PyArduino/cli.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from .compiler import Transpiler
+from .errors import BarmajaError, BoardDetectionError, InternalCompilerError, format_error
+from .toolchain import board_for_port, compile_sketch, detect_board, upload_compiled
+from .doctor import run_doctor
+
+
+def _compile(path: str):
+    return Transpiler().compile_file(path)
+
+
+def _write_line(stream, text: str, *, style: str | None = None) -> None:
+    from .console import write_styled
+
+    write_styled(stream, text, style=style)
+
+
+def _write_warnings(result) -> None:
+    for warning in getattr(result, "warnings", ()) or ():
+        where = ""
+        span = getattr(warning, "span", None)
+        line = getattr(span, "start_line", None) or getattr(span, "line", None)
+        if line:
+            where = f"Line {line}: "
+        text = f"Warning: {where}{warning.message}"
+        if getattr(warning, "hint", None):
+            text += f" ({warning.hint})"
+        _write_line(sys.stderr, text)
+
+
+def _list_packs(*, details: bool) -> int:
+    from . import device_packs as dp
+    from . import api_registry  # noqa: F401  (loads packs)
+    from .toolchain import pinned_library_dirs
+    installed = {p.name.lower() for p in pinned_library_dirs()}
+    dev = os.environ.get("BARMAJA_DEV_LIBRARIES")
+    if dev and Path(dev).is_dir():
+        installed |= {p.name.lower() for p in Path(dev).iterdir() if p.is_dir()}
+    missing_any = False
+    _write_line(sys.stdout, f"{len(dp.LOADED)} device pack(s):")
+    for name, pack in dp.LOADED.items():
+        missing = [d["name"] for d in pack.dependencies
+                   if d.get("library_folder", d["name"]).lower() not in installed]
+        missing_any |= bool(missing)
+        state = "libraries OK" if not missing else "MISSING: " + ", ".join(missing)
+        _write_line(sys.stdout, f"  {name:22s} {pack.status:18s} [{pack.source}] {state}")
+        if details:
+            args = ", ".join(p.name for p in pack.constructor)
+            _write_line(sys.stdout, f"      {pack.title}\n      {name}({args})")
+            for m in pack.methods.values():
+                _write_line(sys.stdout, f"      .{m.name}({', '.join(p.name for p in m.params)}) -> {m.returns}")
+    for err in dp.LOAD_ERRORS:
+        _write_line(sys.stderr, "  SKIPPED " + err)
+    return 2 if (missing_any or dp.LOAD_ERRORS) else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="pyarduino", description="Barmaja PyArduino CLI")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    for cmd, help_text in [
+        ("check", "Parse and validate Python without requiring Arduino CLI"),
+        ("generate", "Generate Arduino C++"),
+        ("verify", "Generate and compile for Arduino Uno"),
+        ("upload", "Generate, auto-detect Uno, compile, and upload"),
+    ]:
+        p = sub.add_parser(cmd, help=help_text)
+        p.add_argument("source")
+        if cmd == "generate":
+            p.add_argument("-o", "--output")
+        if cmd == "upload":
+            p.add_argument("--port", help="Serial port to use when automatic detection is ambiguous (e.g. COM5)")
+        p.add_argument("--details", action="store_true", help="Show technical details for errors")
+
+    sub.add_parser("detect", help="Auto-detect connected Arduino Uno")
+    doctor = sub.add_parser("doctor", help="Check the Barmaja PyArduino environment")
+    doctor.add_argument("--details", action="store_true", help="Show complete technical details")
+    doctor.add_argument("--pictoblox", action="store_true", help="Check the PictoBlox installation")
+
+    adder = sub.add_parser("add-library", help="Add an Arduino library (ZIP or folder). No path = open the Library Adder window")
+    adder.add_argument("path", nargs="?")
+    adder.add_argument("--auto", action="store_true", help="No window: convert, check and install automatically")
+    adder.add_argument("--class", dest="cls", help="Library C++ class to use (default: best guess)")
+    adder.add_argument("--name", help="Class name students will use (default: derived from the library class)")
+    adder.add_argument("--no-compile", action="store_true", help="Skip the Arduino Uno compile test")
+    adder.add_argument("--check-only", action="store_true", help="Check but do not install")
+    rm = sub.add_parser("remove-pack", help="Remove a library added with add-library (moved to backups)")
+    rm.add_argument("name")
+    packs_cmd = sub.add_parser("packs", help="List device packs (extra Arduino libraries/sensors) and check their libraries")
+    packs_cmd.add_argument("--details", action="store_true", help="Show methods and dependencies")
+
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "packs":
+            return _list_packs(details=args.details)
+        if args.command == "add-library":
+            from .library_adder import add_library_auto, run_gui
+            if args.auto and args.path:
+                return add_library_auto(args.path, cls=args.cls, student=args.name, compile=not args.no_compile,
+                                        do_install=not args.check_only)
+            return run_gui(args.path)
+        if args.command == "remove-pack":
+            from .library_adder import remove
+            for line in remove(args.name):
+                _write_line(sys.stdout, line)
+            return 0
+        if args.command == "doctor":
+            report = run_doctor(details=args.details, pictoblox=args.pictoblox, use_cache=not args.details)
+            text = report.detailed() if args.details else report.concise()
+            _write_line(
+                sys.stdout if report.ok else sys.stderr,
+                text,
+                style=None if report.ok else "error",
+            )
+            return 0 if report.ok else 2
+
+        if args.command == "detect":
+            b = detect_board()
+            _write_line(sys.stdout, f"{b.name} detected on {b.port} ({b.fqbn}).")
+            return 0
+
+        result = _compile(args.source)
+        if not (args.command == "generate" and not args.output):
+            _write_warnings(result)
+
+        if args.command == "check":
+            from . import __version__
+            _write_line(sys.stdout, f"Barmaja PyArduino code is valid for {__version__}.")
+            return 0
+
+        if args.command == "generate":
+            if args.output:
+                out = Path(args.output)
+                out.write_text(result.cpp, encoding="utf-8")
+                _write_line(sys.stdout, f"Generated Arduino code: {out}")
+            else:
+                _write_line(sys.stdout, result.cpp)
+            return 0
+
+        if args.command == "verify":
+            from .console import compilation_summary_lines
+            _write_line(sys.stdout, "Compiling sketch...")
+            artifact = compile_sketch(result.cpp)
+            _write_line(sys.stdout, "")
+            for index, line in enumerate(compilation_summary_lines(artifact.memory)):
+                _write_line(sys.stdout, line, style="success" if index == 0 else None)
+            return 0
+
+        if args.command == "upload":
+            from .console import compilation_summary_lines
+            _write_line(sys.stdout, "Compiling sketch...")
+            artifact = compile_sketch(result.cpp)
+            _write_line(sys.stdout, "")
+            for index, line in enumerate(compilation_summary_lines(artifact.memory)):
+                _write_line(sys.stdout, line, style="success" if index == 0 else None)
+            _write_line(sys.stdout, "")
+            _write_line(sys.stdout, "Searching for Arduino Uno...")
+
+            port = args.port or os.environ.get("BARMAJA_PORT")
+            try:
+                board = board_for_port(port) if port else detect_board()
+            except BoardDetectionError as exc:
+                if getattr(exc, "reason", None) != "not-found":
+                    raise
+                ports = ", ".join(getattr(exc, "ports", ()) or ()) or "none"
+                _write_line(sys.stderr, "")
+                _write_line(sys.stderr, "Arduino Uno not detected.", style="error")
+                _write_line(sys.stderr, f"Ports found: {ports}", style="error")
+                _write_line(sys.stderr, "")
+                _write_line(sys.stderr, "Connect the Arduino Uno by USB, wait a few seconds,", style="error")
+                _write_line(sys.stderr, "then run the program again.", style="error")
+                _write_line(sys.stderr, "")
+                _write_line(sys.stderr, "Compilation completed successfully.", style="error")
+                _write_line(sys.stderr, "Upload was not attempted.", style="error")
+                return 2
+
+            if port:
+                _write_line(sys.stdout, f"Arduino Uno selected on {board.port}.")
+            else:
+                _write_line(sys.stdout, f"Arduino Uno detected on {board.port}.")
+            _write_line(sys.stdout, "")
+            _write_line(sys.stdout, "Uploading...")
+            upload_compiled(artifact, board)
+            _write_line(sys.stdout, "Upload completed successfully.", style="success")
+            _write_line(sys.stdout, "")
+            _write_line(sys.stdout, "The Arduino program is now running standalone.", style="success")
+            return 0
+
+    except BarmajaError as exc:
+        show = bool(getattr(args, "details", False)) or os.environ.get("BARMAJA_DEBUG") == "1"
+        text = format_error(exc, details=show)
+        if isinstance(exc, InternalCompilerError) and not show:
+            text += "\nRun the same command again with --details and share the output with your teacher."
+        _write_line(sys.stderr, text, style="error")
+        return 3 if isinstance(exc, InternalCompilerError) else 2
+    except OSError as exc:
+        # File/OS failures are still concise and traceback-free at the student CLI.
+        _write_line(sys.stderr, f"Barmaja PyArduino: {exc}", style="error")
+        return 2
+    except Exception as exc:
+        # Last-resort boundary: never leak a Python traceback to students.
+        wrapped = InternalCompilerError(
+            "An internal Barmaja PyArduino error occurred.",
+            details=f"{type(exc).__name__}: {exc}",
+        )
+        show = bool(getattr(args, "details", False)) or os.environ.get("BARMAJA_DEBUG") == "1"
+        text = format_error(wrapped, details=show)
+        if not show:
+            text += "\nRun the same command again with --details and share the output with your teacher."
+        _write_line(sys.stderr, text, style="error")
+        return 3
+
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())