bluer-objects 6.3.1__py3-none-any.whl

bluer_objects/file/save.py

@@ -0,0 +1,280 @@
+from typing import Any, Dict, List
+import yaml
+import numpy as np
+import json
+import dill
+import pandas as pd
+
+from blueness import module
+from blue_options.logger import crash_report
+from blue_options import string
+from blue_options.host import is_jupyter
+
+from bluer_objects import NAME
+from bluer_objects.file.classes import JsonEncoder
+from bluer_objects.file.functions import path as file_path
+from bluer_objects.file.load import load_text
+from bluer_objects.path import create as path_create
+from bluer_objects.logger import logger
+
+
+NAME = module.name(__file__, NAME)
+
+
+def prepare_for_saving(
+    filename: str,
+) -> bool:
+    return path_create(file_path(filename))
+
+
+def finish_saving(
+    success: bool,
+    message: str,
+    log: bool = True,
+) -> bool:
+    if not success:
+        crash_report(f"{message}: failed.")
+    elif log:
+        logger.info(message)
+
+    return success
+
+
+def save(
+    filename: str,
+    data: Any,
+    log: bool = False,
+) -> bool:
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    try:
+        with open(filename, "wb") as fp:
+            dill.dump(data, fp)
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save: {} -> {}".format(
+            NAME,
+            type(data),
+            filename,
+        ),
+        log,
+    )
+
+
+def save_csv(
+    filename: str,
+    df: pd.DataFrame,
+    log: bool = False,
+):
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    # https://stackoverflow.com/a/10250924/10917551
+    try:
+        df.to_csv(filename)
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save_csv: {:,}X[{}] -> {}".format(
+            NAME,
+            len(df),
+            ",".join(list(df.columns)),
+            filename,
+        ),
+        log,
+    )
+
+
+def save_fig(
+    filename: str,
+    log: bool = False,
+):
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    # https://stackoverflow.com/a/10250924/10917551
+    try:
+        import matplotlib.pyplot as plt
+
+        if is_jupyter():
+            plt.show()
+        plt.savefig(filename, bbox_inches="tight")
+        plt.close()
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        f"{NAME}.save_fig -> {filename}",
+        log,
+    )
+
+
+def save_image(
+    filename: str,
+    image: np.ndarray,
+    log: bool = False,
+):
+    import cv2
+
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    try:
+        data = image.copy()
+
+        if len(data.shape) == 3:
+            data = np.flip(data, axis=2)
+
+        cv2.imwrite(filename, data)
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save_image: {} -> {}".format(
+            NAME,
+            string.pretty_shape_of_matrix(image),
+            filename,
+        ),
+        log,
+    )
+
+
+def save_json(
+    filename: str,
+    data: Any,
+    log: bool = False,
+):
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    try:
+        if hasattr(data, "to_json"):
+            data = data.to_json()
+
+        with open(filename, "w") as fh:
+            json.dump(
+                data,
+                fh,
+                sort_keys=True,
+                cls=JsonEncoder,
+                indent=4,
+                ensure_ascii=False,
+            )
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save_json -> {}".format(
+            NAME,
+            filename,
+        ),
+        log,
+    )
+
+
+def save_matrix(
+    filename: str,
+    matrix: np.ndarray,
+    log: bool = True,
+) -> bool:
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    try:
+        np.save(filename, matrix)
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save_matrix({}) -> {}".format(
+            NAME,
+            string.pretty_shape_of_matrix(matrix),
+            filename,
+        ),
+        log,
+    )
+
+
+def save_text(
+    filename: str,
+    text: List[str],
+    if_different: bool = False,
+    log: bool = False,
+    remove_empty_lines: bool = False,
+) -> bool:
+    if remove_empty_lines:
+        text = [
+            line
+            for line, next_line in zip(text, text[1:] + ["x"])
+            if line.strip() or next_line.strip()
+        ]
+
+    if if_different:
+        _, content = load_text(filename, ignore_error=True)
+
+        if "|".join([line for line in content if line]) == "|".join(
+            [line for line in text if line]
+        ):
+            return True
+
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    try:
+        with open(filename, "w") as fp:
+            fp.writelines([string + "\n" for string in text])
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save_text: {:,} line(s) -> {}".format(
+            NAME,
+            len(text),
+            filename,
+        ),
+        log,
+    )
+
+
+def save_yaml(
+    filename: str,
+    data: Dict,
+    log=True,
+):
+    if not prepare_for_saving(filename):
+        return False
+
+    success = True
+    try:
+        with open(filename, "w") as f:
+            yaml.dump(data, f)
+    except:
+        success = False
+
+    return finish_saving(
+        success,
+        "{}.save_yaml: {} -> {}.".format(
+            NAME,
+            ", ".join(data.keys()),
+            filename,
+        ),
+        log,
+    )

bluer_objects/graphics/__init__.py

@@ -0,0 +1,4 @@
+from bluer_objects.graphics.frame import add_frame
+from bluer_objects.graphics.screen import get_size
+from bluer_objects.graphics.signature import add_signature
+from bluer_objects.graphics.text import render_text

bluer_objects/graphics/__main__.py

@@ -0,0 +1,84 @@
+import argparse
+import glob
+
+from blueness import module
+from blueness.argparse.generic import sys_exit
+
+from bluer_objects import NAME, objects
+from bluer_objects.graphics.gif import generate_animated_gif
+from bluer_objects.graphics import screen
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    default="",
+    help="generate_animated_gif|get_screen_size",
+)
+parser.add_argument(
+    "--object_name",
+    type=str,
+)
+parser.add_argument(
+    "--suffix",
+    default=".png",
+    type=str,
+)
+parser.add_argument(
+    "--output_filename",
+    default="",
+    type=str,
+    help="blank: <object-name>.gif",
+)
+parser.add_argument(
+    "--frame_duration",
+    default=150,
+    type=int,
+    help="ms",
+)
+parser.add_argument(
+    "--scale",
+    default=1,
+    type=int,
+)
+
+args = parser.parse_args()
+
+success = False
+if args.task == "generate_animated_gif":
+    success = generate_animated_gif(
+        list_of_images=sorted(
+            list(
+                glob.glob(
+                    objects.path_of(
+                        f"*{args.suffix}",
+                        args.object_name,
+                    )
+                )
+            )
+        ),
+        output_filename=objects.path_of(
+            filename=(
+                args.output_filename
+                if args.output_filename
+                else "{}{}.gif".format(
+                    args.object_name,
+                    f"-{args.scale}X" if args.scale != 1 else "",
+                )
+            ),
+            object_name=args.object_name,
+        ),
+        frame_duration=args.frame_duration,
+        scale=args.scale,
+    )
+elif args.task == "get_screen_size":
+    success = True
+    print("x".join([str(value) for value in screen.get_size()]))
+else:
+    success = None
+
+sys_exit(logger, NAME, args.task, success)

bluer_objects/graphics/frame.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+
+def add_frame(
+    martrix: np.ndarray,
+    width: int,
+) -> np.ndarray:
+    output = np.zeros(
+        (martrix.shape[0] + 2 * width, martrix.shape[1] + 2 * width, martrix.shape[2]),
+        dtype=martrix.dtype,
+    )
+
+    output[width:-width, width:-width, :] = martrix[:, :, :]
+
+    return output

bluer_objects/graphics/gif.py

@@ -0,0 +1,86 @@
+from PIL import Image
+from tqdm import tqdm
+from typing import List
+
+from blueness import module
+from blue_options.logger import crash_report
+
+from bluer_objects import NAME
+from bluer_objects.logger import logger
+
+
+NAME = module.name(__file__, NAME)
+
+
+def generate_animated_gif(
+    list_of_images: List[str],
+    output_filename: str,
+    frame_duration: int = 150,
+    scale: int = 1,
+    log: bool = True,
+) -> bool:
+    if not list_of_images:
+        return True
+
+    max_width = 0
+    max_height = 0
+    frames = []
+    for filename in tqdm(list_of_images):
+        image = Image.open(filename)
+
+        frames.append(image)
+
+        width, height = image.size
+        max_width = max(max_width, width)
+        max_height = max(max_height, height)
+
+    padded_frames = []
+    for image in frames:
+        padded_image = Image.new(
+            "RGB",
+            (max_width, max_height),
+            (255, 255, 255),
+        )
+
+        width, height = image.size
+        left_pad = (max_width - width) // 2
+        top_pad = (max_height - height) // 2
+        padded_image.paste(image, (left_pad, top_pad))
+
+        if scale != 1:
+            padded_image = padded_image.resize(
+                (max_width // scale, max_height // scale),
+                Image.Resampling.LANCZOS,
+            )
+
+        padded_frames.append(padded_image)
+
+    success = True
+    try:
+        padded_frames[0].save(
+            output_filename,
+            save_all=True,
+            append_images=padded_frames[1:],
+            duration=frame_duration,
+            loop=0,  # 0 means infinite loop
+        )
+    except Exception:
+        success = False
+
+    message = "{}.generate_animated_gif({}x{}x{}) -scale={}-> {} @ {:.2f}ms".format(
+        NAME,
+        len(list_of_images),
+        height,
+        width,
+        scale,
+        output_filename,
+        frame_duration,
+    )
+
+    if success:
+        if log:
+            logger.info(message)
+        return True
+
+    crash_report(message)
+    return False

bluer_objects/graphics/screen.py

@@ -0,0 +1,63 @@
+import os
+from typing import Tuple
+
+from blueness import module
+from blue_options.host.functions import (
+    is_rpi,
+    is_headless,
+    is_mac,
+    is_ec2,
+    is_docker,
+    is_github_workflow,
+    is_jupyter,
+    is_aws_batch,
+)
+
+from bluer_objects import NAME
+from bluer_objects.host import shell
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def get_size() -> Tuple[int, int]:
+    screen_height = 480
+    screen_width = 640
+
+    if is_rpi() and not is_headless():
+        try:
+            # https://stackoverflow.com/a/14124257
+            screen = os.popen("xrandr -q -d :0").readlines()[0]
+            screen_width = int(screen.split()[7])
+            screen_height = int(screen.split()[9][:-1])
+        except Exception as e:
+            logger.error(f"{NAME}: Failed: {e}.")
+    elif is_mac():
+        success, output = shell(
+            "system_profiler SPDisplaysDataType | grep Resolution",
+            clean_after=True,
+            return_output=True,
+        )
+        output = [thing for thing in output if thing]
+        if success and output:
+            screen_width, screen_height = [
+                int(thing) for thing in output[-1].split() if thing.isnumeric()
+            ]
+    elif (
+        not is_ec2()
+        and not is_docker()
+        and not is_github_workflow()
+        and not is_jupyter()
+        and not is_aws_batch()
+    ):
+        try:
+            from gi.repository import Gdk  # type: ignore
+
+            screen = Gdk.Screen.get_default()
+            geo = screen.get_monitor_geometry(screen.get_primary_monitor())
+            screen_width = geo.width
+            screen_height = geo.height
+        except Exception as e:
+            logger.error(f"{NAME}: Failed: {e}.")
+
+    return screen_height, screen_width

bluer_objects/graphics/signature.py

@@ -0,0 +1,97 @@
+from typing import List, Union
+import numpy as np
+from functools import reduce
+import textwrap
+
+from blueness import module
+
+from bluer_objects import NAME
+from bluer_objects import file
+from bluer_objects.graphics.text import render_text
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def justify_text(
+    text: Union[List[str], str],
+    line_width: int = 80,
+    return_str: bool = False,
+) -> Union[List[str], str]:
+    output = reduce(
+        lambda x, y: x + y,
+        [
+            textwrap.wrap(line, width=line_width)
+            for line in (text if isinstance(text, list) else [text])
+        ],
+    )
+
+    return "\n".join(output) if return_str else output
+
+
+def add_signature(
+    image: np.ndarray,
+    header: List[str],
+    footer: List[str] = [],
+    word_wrap: bool = True,
+    line_width: int = 80,
+) -> np.ndarray:
+    if image is None or not image.shape:
+        return image
+
+    if word_wrap:
+        header = justify_text(header, line_width=line_width)
+        footer = justify_text(footer, line_width=line_width)
+
+    justify_line = lambda line: (
+        line if len(line) >= line_width else line + (line_width - len(line)) * " "
+    )
+
+    color_depth = image.shape[2] if len(image.shape) >= 3 else 1
+
+    return np.concatenate(
+        [
+            render_text(
+                text=justify_line(line),
+                image_width=image.shape[1],
+                color_depth=color_depth,
+            )
+            for line in header
+        ]
+        + [image]
+        + [
+            render_text(
+                text=justify_line(line),
+                image_width=image.shape[1],
+                color_depth=color_depth,
+            )
+            for line in footer
+        ],
+        axis=0,
+    )
+
+
+def sign_filename(
+    filename: str,
+    header: List[str],
+    footer: List[str],
+    line_width: int = 80,
+) -> bool:
+    success, image = file.load_image(filename)
+    if not success:
+        return success
+
+    if not file.save_image(
+        filename,
+        add_signature(
+            image,
+            header=[" | ".join(header)],
+            footer=[" | ".join(footer)],
+            line_width=line_width,
+        ),
+    ):
+        return False
+
+    logger.info("-> {}".format(filename))
+
+    return True