bluer-sbc 8.3.1__py3-none-any.whl

bluer_sbc/imager/classes.py

@@ -0,0 +1,25 @@
+from typing import Tuple, List
+import numpy as np
+
+from blueness import module
+
+from bluer_sbc import NAME
+
+NAME = module.name(__file__, NAME)
+
+
+class Imager:
+    def capture(self) -> Tuple[bool, np.ndarray]:
+        return True, np.zeros(())
+
+
+class TemplateImager(Imager):
+    def capture(self) -> Tuple[bool, np.ndarray]:
+        success, image = super().capture()
+
+        # TODO: capture the image here
+
+        return success, image
+
+    def signature(self) -> List[str]:
+        return [self.__class__.__name__]

bluer_sbc/imager/lepton/__init__.py

@@ -0,0 +1,3 @@
+from bluer_sbc.imager.lepton.classes import Lepton
+
+instance = Lepton()

bluer_sbc/imager/lepton/__main__.py

@@ -0,0 +1,51 @@
+import argparse
+import os
+
+from blueness import module
+
+from bluer_sbc import NAME
+from bluer_sbc.imager.lepton import instance as lepton
+from bluer_sbc.hardware import hardware
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    default="",
+    help="capture|preview",
+)
+parser.add_argument(
+    "--filename",
+    default="",
+    type=str,
+)
+parser.add_argument(
+    "--output_path",
+    type=str,
+    default="",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "capture":
+    success, _, _ = lepton.capture(
+        filename=os.path.join(args.output_path, "camera.jpg"),
+    )
+elif args.task == "preview":
+    success = True
+
+    hardware.sign_images = False
+    try:
+        while not hardware.pressed("qe"):
+            _, image = lepton.capture()
+            hardware.update_screen(image)
+    finally:
+        pass
+else:
+    logger.error(f"-{NAME}: {args.task}: command not found.")
+
+if not success:
+    logger.error(f"-{NAME}: {args.task}: failed.")

bluer_sbc/imager/lepton/classes.py

@@ -0,0 +1,35 @@
+from typing import Tuple
+import numpy as np
+
+from blueness import module
+from bluer_options import string
+from bluer_objects import file
+from bluer_objects import path
+from bluer_objects.env import abcli_path_git
+from bluer_objects.host import shell
+
+from bluer_sbc import NAME
+from bluer_sbc.imager.classes import Imager
+from bluer_sbc.logger import logger
+
+
+NAME = module.name(__file__, NAME)
+
+
+class Lepton(Imager):
+    def capture(self) -> Tuple[bool, np.ndarray]:
+        success, image = super().capture()
+
+        temp_dir = path.auxiliary("lepton")
+        success = shell(
+            f"python python2.py capture --output_path {temp_dir}",
+            work_dir=f"{abcli_path_git}/bluer-sbc/bluer_sbc/imager/lepton",
+        )
+
+        if success:
+            success, image = file.load_image(f"{temp_dir}/image.jpg")
+
+        if success:
+            logger.info(f"{NAME}.capture(): {string.pretty_shape_of_matrix(image)}")
+
+        return success, image

bluer_sbc/imager/lepton/python2.py

@@ -0,0 +1,70 @@
+import argparse
+import cv2
+from datetime import datetime
+import numpy as np
+import os.path
+import time
+
+
+def capture(flip_v=True, device="/dev/spidev0.0"):
+    from pylepton import Lepton
+
+    with Lepton(device) as l:
+        a, _ = l.capture()
+
+    if flip_v:
+        cv2.flip(a, 0, a)
+
+    cv2.normalize(a, a, 0, 65535, cv2.NORM_MINMAX)
+    np.right_shift(a, 8, a)
+
+    return np.uint8(a)
+
+
+def capture_and_save(path):
+    try:
+        for _ in range(2):
+            image = capture(False, "/dev/spidev0.0")
+            time.sleep(1)
+
+        cv2.imwrite(os.path.join(path, "image_raw.jpg"), image)
+
+        cv2.imwrite(
+            os.path.join(path, "image.jpg"),
+            cv2.resize(image, (1280, 960), interpolation=cv2.INTER_NEAREST),
+        )
+
+        print(
+            "lepton.capture_and_save({}) completed: {}.".format(
+                path, "x".join([str(dim) for dim in image.shape])
+            )
+        )
+    except Exception as e:
+        print("lepton.capture_and_save() crashed: {}".format(e))
+        return False
+
+    return True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "task",
+        type=str,
+        default="",
+        help="capture",
+    )
+    parser.add_argument(
+        "--output_path",
+        default="",
+    )
+    args = parser.parse_args()
+
+    success = False
+    if args.task == "capture":
+        success = capture_and_save(args.output_path)
+    else:
+        print("-lepton: {}: command not found.".format(args.task))
+
+    if not success:
+        print("-lepton: {}: failed.".format(args.task))

bluer_sbc/logger.py

@@ -0,0 +1,5 @@
+from bluer_options.logger import get_logger
+
+from bluer_sbc import ICON
+
+logger = get_logger(ICON)

bluer_sbc/sample.env

@@ -0,0 +1 @@
+BLUER_SBC_SECRET=value

bluer_sbc/session/__main__.py

@@ -0,0 +1,27 @@
+import argparse
+
+from blueness import module
+
+from bluer_sbc import NAME
+from bluer_sbc.session.classes import Session
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    help="start",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "start":
+    success = Session.start()
+else:
+    logger.error(f"-{NAME}: {args.task}: command not found.")
+
+if not success:
+    logger.error(f"-{NAME}: {args.task}: failed.")

bluer_sbc/session/classes.py

@@ -0,0 +1,318 @@
+import os
+
+from blueness import module
+from bluer_options import string
+from bluer_options import host
+from bluer_options.logger import crash_report
+from bluer_options.timer import Timer
+from bluer_objects import file
+from bluer_objects import objects
+from bluer_objects.storage import instance as storage
+from bluer_objects.graphics.signature import add_signature
+from bluer_ai import VERSION as abcli_VERSION
+from bluer_ai.modules import terraform
+from bluer_objects.env import abcli_object_name
+
+from bluer_sbc import NAME
+from bluer_sbc import env
+from bluer_sbc.host import signature
+from bluer_sbc.session.functions import reply_to_bash
+from bluer_sbc.algo.diff import Diff
+from bluer_sbc.hardware import hardware
+from bluer_sbc.imager import imager
+from bluer_sbc.logger import logger
+
+
+NAME = module.name(__file__, NAME)
+
+
+class Session:
+    def __init__(self):
+        self.bash_keys = {
+            "e": "exit",
+            "r": "reboot",
+            "s": "shutdown",
+            "u": "update",
+        }
+
+        self.diff = Diff(env.BLUER_SBC_SESSION_IMAGER_DIFF)
+
+        self.capture_requested = False
+
+        self.frame = 0
+        self.new_frame = False
+        self.frame_image = terraform.poster(None)
+        self.frame_filename = ""
+
+        self.auto_upload = env.BLUER_SBC_SESSION_AUTO_UPLOAD
+
+        self.messages = []
+
+        self.model = None
+
+        self.params = {"iteration": -1}
+
+        self.state = {}
+
+        self.timer = {}
+        for name, period in {
+            "imager": env.BLUER_SBC_SESSION_IMAGER_PERIOD,
+            "messenger": env.BLUER_SBC_SESSION_MESSENGER_PERIOD,
+            "reboot": env.BLUER_SBC_SESSION_REBOOT_PERIOD,
+            "screen": env.BLUER_SBC_SESSION_SCREEN_PERIOD,
+            "temperature": env.BLUER_SBC_SESSION_TEMPERATURE_PERIOD,
+        }.items():
+            self.add_timer(name, period)
+
+    def add_timer(
+        self,
+        name: str,
+        period: float,
+    ):
+        if name not in self.timer:
+            self.timer[name] = Timer(period, name)
+            logger.info(
+                "{}: timer[{}]:{}".format(
+                    NAME,
+                    name,
+                    string.pretty_frequency(1 / period),
+                )
+            )
+            return True
+        return False
+
+    def check_imager(self):
+        self.new_frame = False
+
+        if not env.BLUER_SBC_SESSION_IMAGER_ENABLED:
+            return
+        if not self.capture_requested and not self.timer["imager"].tick():
+            return
+        self.capture_requested = False
+
+        success, image = imager.capture()
+        if not success:
+            return
+
+        hardware.pulse("data")
+
+        if self.diff.same(image):
+            return
+
+        self.frame += 1
+
+        image = add_signature(
+            image,
+            [" | ".join(objects.signature(self.frame))],
+            [" | ".join(signature())],
+        )
+
+        filename = objects.path_of(
+            object_name=abcli_object_name,
+            filename=f"{self.frame:016d}.jpg",
+        )
+        if not file.save_image(filename, image):
+            return
+
+        self.new_frame = True
+        self.frame_image = image
+        self.frame_filename = filename
+
+        if self.auto_upload:
+            storage.upload_file(self.frame_filename)
+
+    def check_keys(self):
+        for key in hardware.key_buffer:
+            if key in self.bash_keys:
+                reply_to_bash(self.bash_keys[key])
+                return False
+
+        if " " in hardware.key_buffer:
+            self.capture_requested = True
+
+        hardware.key_buffer = []
+
+        return None
+
+    def check_seed(self):
+        seed_filename = host.get_seed_filename()
+        if not file.exists(seed_filename):
+            return None
+
+        success, content = file.load_json(file.set_extension(seed_filename, "json"))
+        if not success:
+            return None
+
+        hardware.pulse("outputs")
+
+        seed_version = content.get("version", "")
+        if seed_version <= abcli_VERSION:
+            return None
+
+        logger.info(f"{NAME}: seed {seed_version} detected.")
+        reply_to_bash("seed", [seed_filename])
+        return False
+
+    def check_timers(self):
+        if self.timer["screen"].tick():
+            hardware.update_screen(
+                image=self.frame_image,
+                session=self,
+                header=self.signature(),
+            )
+        elif hardware.animated:
+            hardware.animate()
+
+        if self.timer["reboot"].tick("wait"):
+            reply_to_bash("reboot")
+            return False
+
+        if self.timer["temperature"].tick():
+            self.read_temperature()
+
+        return None
+
+    def close(self):
+        hardware.release()
+
+    def process_message(self, message):
+        if (
+            env.BLUER_SBC_SESSION_OUTBOUND_QUEUE
+            and message.subject in "bolt,frame".split(",")
+            and not host.is_headless()
+        ):
+            logger.info(f"{NAME}: frame received: {message.as_string()}")
+            self.new_frame, self.frame_image = file.load_image(message.filename)
+
+        if message.subject == "capture":
+            logger.info(f"{NAME}: capture message received.")
+            self.capture_requested = True
+
+        if message.subject in "reboot,shutdown".split(","):
+            logger.info(f"{NAME}: {message.subject} message received.")
+            reply_to_bash(message.subject)
+            return False
+
+        if message.subject == "update":
+            try:
+                if message.data["version"] > abcli_VERSION:
+                    reply_to_bash("update")
+                    return False
+            except Exception as e:
+                crash_report(e)
+
+        return None
+
+    # https://www.cyberciti.biz/faq/linux-find-out-raspberry-pi-gpu-and-arm-cpu-temperature-command/
+    def read_temperature(self):
+        if not host.is_rpi():
+            return
+
+        params = {}
+
+        success, output = file.load_text("/sys/class/thermal/thermal_zone0/temp")
+        if success:
+            output = [thing for thing in output if thing]
+            if output:
+                try:
+                    params["temperature.cpu"] = float(output[0]) / 1000
+                except Exception as e:
+                    crash_report(e)
+                    return
+
+        self.params.update(params)
+        logger.info(
+            "{}: {}".format(
+                NAME,
+                ", ".join(string.pretty_param(params)),
+            )
+        )
+
+    def signature(self):
+        return [
+            " | ".join(objects.signature()),
+            " | ".join(sorted([timer.signature() for timer in self.timer.values()])),
+            " | ".join(
+                (["*"] if self.new_frame else [])
+                + (["^"] if self.auto_upload else [])
+                + ([f">{self.outbound_queue}"] if self.outbound_queue else [])
+                + hardware.signature()
+                + [
+                    "diff: {:.03f} - {}".format(
+                        self.diff.last_diff,
+                        string.pretty_duration(
+                            self.diff.last_same_period,
+                            largest=True,
+                            include_ms=True,
+                            short=True,
+                        ),
+                    ),
+                    string.pretty_shape_of_matrix(self.frame_image),
+                ]
+                + ([] if self.model is None else self.model.signature())
+            ),
+        ]
+
+    @staticmethod
+    def start():
+        success = True
+        logger.info(f"{NAME}: started ...")
+
+        try:
+            session = Session()
+
+            while session.step():
+                pass
+
+            logger.info(f"{NAME}: stopped.")
+        except KeyboardInterrupt:
+            logger.info(f"{NAME}: Ctrl+C: stopped.")
+            reply_to_bash("exit")
+        except Exception as e:
+            crash_report(e)
+            success = False
+
+        try:
+            session.close()
+        except Exception as e:
+            crash_report(e)
+            success = False
+
+        return success
+
+    def step(
+        self,
+        steps="all",
+    ) -> bool:
+        if steps == "all":
+            steps = "imager,keys,messages,seed,switch,timers".split(",")
+
+        self.params["iteration"] += 1
+
+        hardware.pulse("loop", 0)
+
+        for enabled, step_ in zip(
+            [
+                "keys" in steps,
+                "messages" in steps,
+                "timers" in steps,
+                "seed" in steps,
+                "imager" in steps,
+            ],
+            [
+                self.check_keys,
+                self.check_messages,
+                self.check_timers,
+                self.check_seed,
+                self.check_imager,
+            ],
+        ):
+            if not enabled:
+                continue
+            output = step_()
+            if output in [False, True]:
+                return output
+
+            hardware.clock()
+
+        return True

bluer_sbc/session/functions.py

@@ -0,0 +1,22 @@
+import os
+from typing import List
+
+from bluer_ai.env import ABCLI_PATH_IGNORE
+from bluer_objects import file
+
+from bluer_sbc.logger import logger
+
+
+def reply_to_bash(
+    status: str,  # exit/reboot/seed/shutdown/update
+    content: List[str] = [],
+) -> bool:
+    logger.info(f"session.reply_to_bash({status}).")
+
+    return file.save_text(
+        filename=os.path.join(
+            ABCLI_PATH_IGNORE,
+            f"session_reply_{status}",
+        ),
+        text=content,
+    )

bluer_sbc/urls.py

@@ -0,0 +1 @@
+urlpatterns = []

bluer_sbc-8.3.1.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: bluer_sbc
+Version: 8.3.1
+Summary: 🌀 AI for single board computers.
+Home-page: https://github.com/kamangir/bluer-sbc
+Author: Arash Abadpour (Kamangir)
+Author-email: arash@kamangir.net
+License: Public Domain
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Unix Shell
+Classifier: License :: Public Domain
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bluer_ai
+Requires-Dist: bluer_sbc
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# 🌀 bluer-sbc
+
+🌀 `bluer-sbc` is a [`bluer-ai`](https://github.com/kamangir/bluer-ai) plugin for edge computing on [single board computers](https://github.com/kamangir/blue-bracket). 
+
+```bash
+pip install bluer_sbc
+
+# @env dot list
+@env dot cp <env-name> local
+```
+
+|   |   |   |   |
+| --- | --- | --- | --- |
+| [![image](https://github.com/kamangir/blue-bracket/raw/main/images/blue3-1.jpg)](https://github.com/kamangir/blue-bracket/blob/main/designs/blue3.md) | [![image](https://github.com/kamangir/blue-bracket/raw/main/images/chenar-grove-1.jpg)](https://github.com/kamangir/blue-bracket/blob/main/designs/chenar-grove.md) | [![image](https://github.com/kamangir/blue-bracket/raw/main/images/cube-1.jpg)](https://github.com/kamangir/blue-bracket/blob/main/designs/cube.md) | [![image](https://github.com/kamangir/blue-bracket/raw/main/images/eye_nano-1.jpg)](https://github.com/kamangir/blue-bracket/blob/main/designs/eye_nano.md) |
+
+
+
+---
+
+> 🌀 [`blue-sbc`](https://github.com/kamangir/blue-sbc) for the [Global South](https://github.com/kamangir/bluer-south).
+
+---
+
+
+[![pylint](https://github.com/kamangir/bluer-sbc/actions/workflows/pylint.yml/badge.svg)](https://github.com/kamangir/bluer-sbc/actions/workflows/pylint.yml) [![pytest](https://github.com/kamangir/bluer-sbc/actions/workflows/pytest.yml/badge.svg)](https://github.com/kamangir/bluer-sbc/actions/workflows/pytest.yml) [![bashtest](https://github.com/kamangir/bluer-sbc/actions/workflows/bashtest.yml/badge.svg)](https://github.com/kamangir/bluer-sbc/actions/workflows/bashtest.yml) [![PyPI version](https://img.shields.io/pypi/v/bluer-sbc.svg)](https://pypi.org/project/bluer-sbc/) [![PyPI - Downloads](https://img.shields.io/pypi/dd/bluer-sbc)](https://pypistats.org/packages/bluer-sbc)
+
+built by 🌀 [`bluer_options-5.32.1`](https://github.com/kamangir/awesome-bash-cli), based on 🌀 [`bluer_sbc-8.3.1`](https://github.com/kamangir/bluer-sbc).
+
+
+
+built by 🌀 [`blueness-3.96.1`](https://github.com/kamangir/blueness).