bluer-sbc 8.188.1__py3-none-any.whl → 9.168.1__py3-none-any.whl

bluer_sbc/README/designs/swallow_head.py

@@ -0,0 +1,89 @@
+from bluer_objects import README
+from bluer_objects.README.items import ImageItems
+
+from bluer_sbc.README.designs.consts import assets2
+from bluer_sbc.README.design import design_doc
+
+
+image_template = assets2 + "swallow/design/head-v1/{}?raw=true"
+
+marquee = README.Items(
+    [
+        {
+            "name": "swallow head",
+            "marquee": image_template.format("01.jpg"),
+            "url": "./bluer_sbc/docs/swallow-head.md",
+        }
+    ]
+)
+
+items = ImageItems(
+    {image_template.format(f"{index+1:02}.jpg"): "" for index in range(6)}
+)
+
+parts = {
+    "sd-card-32-gb": "",
+    "rpi": "",
+    "XL4015": "",
+    "470-mF": "",
+    "Polyfuse": "optional",
+    "TVS-diode": "",
+    "resistor": "7 x 330-470 Ω + N x 2.2 kΩ + N x 3.3 kΩ",
+    "LED": "green + red + yellow + 4 x blue",
+    "rpi-camera": "",
+    "PCB-single-14x9_5": "2 x",
+    "PCB-double-9x7": "2 x",
+    "pushbutton": "",
+    "ultrasonic-sensor": "4 x",
+    "connector": "1 female",
+    "nuts-bolts-spacers": " + ".join(
+        [
+            "M2: ({})".format(
+                " + ".join(
+                    [
+                        "2 x bolt",
+                        "2 x 5 mm spacer",
+                        "4 x nut",
+                    ]
+                )
+            ),
+            "M2.5: ({})".format(
+                " + ".join(
+                    [
+                        "4 x bolt",
+                        "8 x 10 mm spacer",
+                        "4 x nut",
+                    ]
+                )
+            ),
+            "M3: ({})".format(
+                " + ".join(
+                    [
+                        "1 x bolt",
+                        "3 x 35 mm spacer",
+                        "3 x 25 mm spacer",
+                        "7 x 15 mm spacer",
+                        "4 x 5 mm spacer",
+                        "5 x nut",
+                    ]
+                )
+            ),
+        ]
+    ),
+    "plexiglass": "14 cm x 9.5 cm",
+    "white-terminal": "2 x",
+    "dupont-cables": "1 x 30 cm + 1 x 10 cm",
+    "16-awg-wire": "40 cm x (red + black/blue)",
+    "solid-cable-1-15": "10 cm x (red + black/blue)",
+    "strong-thread": "1 m",
+    "pin-headers": "1 x (female, 2 x 40) -> 2 x 20 + 2 x (male, 1 x 40) -> 4 x 6 + 4 x 2 + 2 x 20",
+}
+
+
+docs = [
+    design_doc(
+        "swallow-head",
+        items,
+        parts,
+    )
+]

bluer_sbc/README/designs/template.py

@@ -0,0 +1,38 @@
+from bluer_objects import README
+from bluer_objects.README.items import ImageItems
+from bluer_objects.README.consts import assets_url
+
+from bluer_sbc.README.design import design_doc
+
+
+assets2_x = assets_url(
+    suffix="x",
+    volume=2,
+)
+
+marquee = README.Items(
+    [
+        {
+            "name": "x",
+            "marquee": f"{assets2_x}/TBA.jpg",
+            "url": "./bluer_sbc/docs/x.md",
+        }
+    ]
+)
+
+items = ImageItems(
+    {
+        f"{assets2_x}/TBA.jpg": "",
+        f"{assets2_x}/TBA.jpg": "",
+    }
+)
+
+parts = {}
+
+docs = [
+    design_doc(
+        "template",
+        items,
+        parts,
+    )
+]

bluer_sbc/{designs → README/designs}/ultrasonic_sensor_tester.py

@@ -1,6 +1,8 @@
 from bluer_objects import README
+from bluer_objects.README.items import ImageItems
 
-from bluer_sbc.designs.consts import assets2
+from bluer_sbc.README.designs.consts import assets2
+from bluer_sbc.README.design import design_doc
 
 
 image_template = assets2 + "ultrasonic-sensor-tester/{}?raw=true"
@@ -15,12 +17,11 @@ marquee = README.Items(
     ]
 )
 
-items = README.Items(
-    [
-        {
-            "marquee": image_template.format(f"{index:02}.jpg"),
-            "name": "",
-        }
-        for index in range(6)
-    ]
-)
+items = ImageItems({image_template.format(f"{index:02}.jpg"): "" for index in range(6)})
+
+docs = [
+    design_doc(
+        "ultrasonic-sensor-tester",
+        items,
+    )
+]

bluer_sbc/README/parts.py

@@ -0,0 +1,29 @@
+from bluer_objects import markdown
+
+from bluer_sbc.parts.db import db_of_parts
+
+docs = [
+    {
+        "path": "../docs/parts",
+        "macros": {
+            "parts_list:::": db_of_parts.README,
+            "parts_images:::": markdown.generate_table(
+                db_of_parts.as_images(
+                    {part.name: "" for part in db_of_parts},
+                    reference="../parts",
+                ),
+                cols=10,
+                log=False,
+            ),
+        },
+    }
+] + [
+    {
+        "path": part.filename(create=True),
+        "macros": {
+            "info:::": part.README(db_of_parts.url_prefix),
+        },
+    }
+    for part_name, part in db_of_parts.items()
+    if part_name != "template"
+]

bluer_sbc/README/root.py

@@ -0,0 +1,33 @@
+from bluer_sbc.README.designs.cheshmak import marquee as cheshmak_marquee
+from bluer_sbc.README.designs.blue_bracket import items as blue_bracket_items
+from bluer_sbc.README.designs.swallow import marquee as swallow_marquee
+from bluer_sbc.README.designs.swallow_head import marquee as swallow_head_marquee
+from bluer_sbc.README.designs.bryce import marquee as bryce_marquee
+from bluer_sbc.README.designs.nafha import marquee as nafha_marquee
+from bluer_sbc.README.designs.shelter import marquee as shelter_marquee
+from bluer_sbc.README.designs.adapter_bus import marquee as adapter_bus_marquee
+from bluer_sbc.README.designs.battery_bus import marquee as battery_bus_marquee
+from bluer_sbc.README.designs.ultrasonic_sensor_tester import (
+    marquee as ultrasonic_sensor_tester_marquee,
+)
+from bluer_sbc.README.shortcuts import items as shortcuts_items
+
+docs = [
+    {
+        "items": []
+        + swallow_head_marquee
+        + swallow_marquee
+        + battery_bus_marquee
+        + adapter_bus_marquee
+        + ultrasonic_sensor_tester_marquee
+        + bryce_marquee
+        + cheshmak_marquee
+        + nafha_marquee
+        + shelter_marquee
+        + blue_bracket_items,
+        "path": "../..",
+        "macros": {
+            "shortcuts:::": shortcuts_items,
+        },
+    },
+]

bluer_sbc/README/shortcuts.py

@@ -0,0 +1,18 @@
+from bluer_objects.README.items import Items
+from bluer_objects import markdown
+
+from bluer_sbc.parts.db import db_of_parts
+
+
+items = markdown.generate_table(
+    Items(
+        [
+            {
+                "name": "parts",
+                "url": "./bluer_sbc/docs/parts",
+                "marquee": f"{db_of_parts.url_prefix}/grid.png",
+            },
+        ]
+    ),
+    log=False,
+)

bluer_sbc/__init__.py

@@ -2,9 +2,9 @@ NAME = "bluer_sbc"
 
 ICON = "🌀"
 
-DESCRIPTION = f"{ICON} AI for single board computers."
+DESCRIPTION = f"{ICON} AI for single board computers and related designs."
 
-VERSION = "8.188.1"
+VERSION = "9.168.1"
 
 REPO_NAME = "bluer-sbc"
 

bluer_sbc/__main__.py

@@ -1,6 +1,7 @@
 from blueness.argparse.generic import main
 
-from bluer_sbc import NAME, VERSION, DESCRIPTION, ICON, README
+from bluer_sbc import NAME, VERSION, DESCRIPTION, ICON
+from bluer_sbc.README.build import build
 from bluer_sbc.logger import logger
 
 main(
@@ -10,7 +11,7 @@ main(
     VERSION=VERSION,
     main_filename=__file__,
     tasks={
-        "build_README": lambda _: README.build(),
+        "build_README": lambda _: build(),
     },
     logger=logger,
 )

bluer_sbc/config.env

@@ -29,4 +29,4 @@ BLUER_SBC_SESSION_REBOOT_PERIOD=14400
 BLUER_SBC_SESSION_SCREEN_PERIOD=4
 BLUER_SBC_SESSION_TEMPERATURE_PERIOD=300
 
-BLUER_SBC_ENV=navigation
+BLUER_SBC_ENV=navigation

bluer_sbc/env.py

@@ -38,3 +38,7 @@ BLUER_SBC_SESSION_TEMPERATURE_PERIOD = get_env(
 BLUER_SBC_ENV = get_env("BLUER_SBC_ENV")
 
 BLUER_SBC_SWALLOW_HAS_STEERING = get_env("BLUER_SBC_SWALLOW_HAS_STEERING", 0)
+BLUER_SBC_SWALLOW_HAS_FULL_KEYBOARD = get_env("BLUER_SBC_SWALLOW_HAS_FULL_KEYBOARD", 0)
+BLUER_SBC_SWALLOW_HAS_BPS = get_env("BLUER_SBC_SWALLOW_HAS_BPS", 0)
+
+BLUER_SBC_BPS_ANCHORED_AT = get_env("BLUER_SBC_BPS_ANCHORED_AT", "")

bluer_sbc/help/functions.py

@@ -10,6 +10,7 @@ from bluer_sbc.help.camera import help_functions as help_camera
 from bluer_sbc.help.grove import help_functions as help_grove
 from bluer_sbc.help.hat import help_functions as help_hat
 from bluer_sbc.help.lepton import help_functions as help_lepton
+from bluer_sbc.help.parts import help_functions as help_parts
 from bluer_sbc.help.rpi import help_functions as help_rpi
 from bluer_sbc.help.scroll_phat_hd import help_functions as help_scroll_phat_hd
 from bluer_sbc.help.sparkfun_top_phat import help_functions as help_sparkfun_top_phat
@@ -26,6 +27,7 @@ help_functions.update(
         "grove": help_grove,
         "hat": help_hat,
         "lepton": help_lepton,
+        "parts": help_parts,
         "rpi": help_rpi,
         "scroll_phat_hd": help_scroll_phat_hd,
         "sparkfun_top_phat": help_sparkfun_top_phat,

bluer_sbc/help/parts.py

@@ -0,0 +1,49 @@
+from typing import List
+
+from bluer_options.terminal import show_usage, xtra
+
+from bluer_sbc import ALIAS
+
+
+def help_cd(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "parts",
+            "cd",
+        ],
+        "cd to part images.",
+        mono=mono,
+    )
+
+
+def help_adjust(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = xtra("dryrun,~grid", mono=mono)
+
+    args = [
+        "[--verbose 1]",
+    ]
+
+    return show_usage(
+        [
+            "@sbc",
+            "parts",
+            "adjust",
+            f"[{options}]",
+        ]
+        + args,
+        "adjust part images.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "adjust": help_adjust,
+    "cd": help_cd,
+}

bluer_sbc/help/rpi.py

@@ -11,7 +11,8 @@ def help_fake_display(
 
     return show_usage(
         [
-            "@rpi",
+            "@sbc",
+            "rpi",
             "fake_display",
             f"[{options}]",
         ],

bluer_sbc/parts/__main__.py

@@ -0,0 +1,48 @@
+import argparse
+
+from blueness import module
+from blueness.argparse.generic import sys_exit
+
+from bluer_sbc import NAME
+from bluer_sbc.parts.db import db_of_parts
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    help="adjust",
+)
+parser.add_argument(
+    "--dryrun",
+    type=int,
+    default=1,
+    help="0 | 1",
+)
+parser.add_argument(
+    "--generate_grid",
+    type=int,
+    default=1,
+    help="0 | 1",
+)
+parser.add_argument(
+    "--verbose",
+    type=int,
+    default=0,
+    help="0 | 1",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "adjust":
+    success = db_of_parts.adjust(
+        generate_grid=args.generate_grid == 1,
+        dryrun=args.dryrun == 1,
+        verbose=args.verbose == 1,
+    )
+else:
+    success = None
+
+sys_exit(logger, NAME, args.task, success)

bluer_sbc/parts/classes/db.py

@@ -0,0 +1,233 @@
+from typing import Dict, List, Iterator, Tuple
+import copy
+import os
+import numpy as np
+import cv2
+from functools import reduce
+from tqdm import tqdm
+
+from blueness import module
+from bluer_options.logger import log_list
+from bluer_objects import file
+from bluer_objects import README
+from bluer_objects.README.consts import assets_path, assets_url
+from bluer_objects.logger.image import log_image_grid
+
+from bluer_sbc.host import signature
+from bluer_sbc import NAME
+from bluer_sbc.parts.classes.part import Part
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+class PartDB:
+    def __init__(self):
+        self._db: Dict[str, Part] = {}
+
+        suffix = "bluer-sbc/parts"
+        self.url_prefix = assets_url(
+            suffix=suffix,
+            volume=2,
+        )
+        self.path = assets_path(
+            suffix=suffix,
+            volume=2,
+        )
+
+    def __iter__(self):
+        return iter(self._db.values())
+
+    def __setitem__(
+        self,
+        name: str,
+        part: Part,
+    ):
+        assert isinstance(part, Part)
+
+        self._db[name] = copy.deepcopy(part)
+        self._db[name].name = name
+
+    def __getitem__(self, name: str) -> Part:
+        return self._db[name]
+
+    def items(self) -> Iterator[Tuple[str, Part]]:
+        return self._db.items()
+
+    @property
+    def README(self) -> List[str]:
+        return sorted(
+            [
+                "1. [{}](./{}.md).".format(
+                    part.info[0],
+                    part.name,
+                )
+                for part in self
+            ]
+        )
+
+    def adjust(
+        self,
+        generate_grid: bool = True,
+        dryrun: bool = True,
+        verbose: bool = False,
+    ) -> bool:
+        logger.info(
+            "{}.adjust{}".format(
+                NAME,
+                " [dryrun]" if dryrun else "",
+            )
+        )
+
+        list_of_filenames = reduce(
+            lambda x, y: x + y,
+            [
+                [part.images[0]]
+                for part_name, part in self._db.items()
+                if part_name != "template" and part.images
+            ],
+            [],
+        )
+        log_list(logger, "adjusting", list_of_filenames, "images")
+
+        if generate_grid:
+            if not log_image_grid(
+                items=[
+                    {
+                        "filename": os.path.join(self.path, part.images[0]),
+                        "title": part_name,
+                    }
+                    for part_name, part in self._db.items()
+                    if part_name != "template" and part.images
+                ],
+                filename=assets_path(
+                    suffix="bluer-sbc/parts/grid.png",
+                    volume=2,
+                ),
+                scale=3,
+                header=[
+                    "{} part(s)".format(len(self._db) - 1),
+                ],
+                footer=signature(),
+            ):
+                return False
+
+        max_width = 0
+        max_height = 0
+        for filename in tqdm(list_of_filenames):
+            success, image = file.load_image(
+                os.path.join(self.path, filename),
+                log=verbose,
+            )
+            if not success:
+                return success
+
+            max_height = max(max_height, image.shape[0])
+            max_width = max(max_width, image.shape[1])
+
+        logger.info(f"size: {max_height} x {max_width}")
+
+        for filename in tqdm(list_of_filenames):
+            success, image = file.load_image(
+                os.path.join(self.path, filename),
+                log=verbose,
+            )
+            if not success:
+                return success
+
+            if image.shape[0] == max_height and image.shape[1] == max_width:
+                logger.info("✅")
+                continue
+
+            image = image[:, :, :3]
+
+            scale = min(
+                max_height / image.shape[0],
+                max_width / image.shape[1],
+            )
+            image = cv2.resize(
+                image,
+                dsize=(
+                    int(scale * image.shape[1]),
+                    int(scale * image.shape[0]),
+                ),
+                interpolation=cv2.INTER_LINEAR,
+            )
+
+            padded_image = (
+                np.ones(
+                    (max_height, max_width, 3),
+                    dtype=np.uint8,
+                )
+                * 255
+            )
+
+            y_offset = (max_height - image.shape[0]) // 2
+            x_offset = (max_width - image.shape[1]) // 2
+
+            padded_image[
+                y_offset : y_offset + image.shape[0],
+                x_offset : x_offset + image.shape[1],
+            ] = image
+
+            if not dryrun:
+                if not file.save_image(
+                    os.path.join(self.path, filename),
+                    padded_image,
+                    log=verbose,
+                ):
+                    return False
+
+        return True
+
+    def as_images(
+        self,
+        dict_of_parts: Dict[str, str],
+        reference: str = "../../parts",
+    ) -> List[str]:
+        return README.Items(
+            [
+                {
+                    "name": self._db[part_name].info[0],
+                    "marquee": self._db[part_name].image_url(
+                        url_prefix=self.url_prefix
+                    ),
+                    "description": description,
+                    "url": f"{reference}/{part_name}.md",
+                }
+                for part_name, description in dict_of_parts.items()
+            ],
+            sort=True,
+        )
+
+    def as_list(
+        self,
+        dict_of_parts: Dict[str, str],
+        reference: str = "../../parts",
+        log: bool = True,
+    ) -> List[str]:
+        if log:
+            logger.info(
+                "{}.as_list: {}".format(
+                    self.__class__.__name__,
+                    ", ".join(dict_of_parts.keys()),
+                )
+            )
+
+        for part_name in dict_of_parts:
+            if part_name not in self._db:
+                logger.error(f"{part_name}: part not found.")
+                assert False
+
+        return sorted(
+            [
+                (
+                    "1. [{}]({}){}.".format(
+                        self._db[part_name].info[0],
+                        f"{reference}/{part_name}.md",
+                        ": {}".format(description) if description else "",
+                    )
+                )
+                for part_name, description in dict_of_parts.items()
+            ]
+        )