bluer-objects 6.104.1__py3-none-any.whl → 6.377.1__py3-none-any.whl

bluer_objects/help/mlflow/__init__.py

@@ -3,6 +3,7 @@ from typing import List
 from bluer_options.terminal import show_usage, xtra
 
 from bluer_objects.help.mlflow.cache import help_functions as help_cache
+from bluer_objects.help.mlflow.lock import help_functions as help_lock
 from bluer_objects.help.mlflow.tags import help_functions as help_tags
 from bluer_ai import env
 
@@ -29,7 +30,7 @@ def help_deploy(
     tokens: List[str],
     mono: bool,
 ) -> str:
-    options = xtra("dryrun,~local,port=<5001>", mono=mono)
+    options = xtra("dryrun,port=<5001>", mono=mono)
 
     return show_usage(
         [
@@ -42,6 +43,22 @@ def help_deploy(
     )
 
 
+def help_deploy_set(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@mlflow",
+            "deploy",
+            "set",
+            "<url> | local",
+        ],
+        "set mlflow deployment.",
+        mono=mono,
+    )
+
+
 def help_get_id(
     tokens: List[str],
     mono: bool,
@@ -198,10 +215,14 @@ def help_transition(
 help_functions = {
     "browse": help_browse,
     "cache": help_cache,
-    "deploy": help_deploy,
+    "deploy": {
+        "": help_deploy,
+        "set": help_deploy_set,
+    },
     "get_id": help_get_id,
     "get_run_id": help_get_run_id,
     "list_registered_models": help_list_registered_models,
+    "lock": help_lock,
     "log_artifacts": help_log_artifacts,
     "log_run": help_log_run,
     "rm": help_rm,

bluer_objects/help/mlflow/lock.py

@@ -0,0 +1,52 @@
+from typing import List
+
+from bluer_options.terminal import show_usage, xtra
+
+
+def help_lock(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    args = [
+        "[--lock <lock-name>]",
+        "[--timeout <10>]",
+        "[--verbose 0]",
+    ]
+
+    return show_usage(
+        [
+            "@lock",
+            "lock",
+            "[.|<object-name>]",
+        ]
+        + args,
+        "lock <object-name>.",
+        mono=mono,
+    )
+
+
+def help_unlock(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    args = [
+        "[--lock <lock-name>]",
+        "[--verbose 0]",
+    ]
+
+    return show_usage(
+        [
+            "@lock",
+            "unlock",
+            "[.|<object-name>]",
+        ]
+        + args,
+        "unlock <object-name>.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "lock": help_lock,
+    "unlock": help_unlock,
+}

bluer_objects/help/pdf.py

@@ -0,0 +1,67 @@
+from typing import List
+
+from bluer_options.terminal import show_usage, xtra
+
+
+def help_convert(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = "".join(
+        [
+            "combine",
+            xtra(",~compress,filename=<release.pdf>,install,", mono=mono),
+            "upload",
+        ]
+    )
+
+    args = [
+        "[--count <2>]",
+    ]
+
+    # ---
+
+    usage_1 = show_usage(
+        [
+            "@pdf",
+            "convert",
+            "[{}]".format(f"inline,{options}"),
+            "<module-name>",
+            "<.,this,this/that.md,this/that.jpg,this/that.pdf>",
+            "[-|<object-name>]",
+        ]
+        + args,
+        "md -> pdf.",
+        mono=mono,
+    )
+
+    # ---
+
+    usage_2 = show_usage(
+        [
+            "@pdf",
+            "convert",
+            f"[{options}]",
+            "[.|<object-name>]",
+        ]
+        + args
+        + [
+            "[--list_missing 0]",
+        ],
+        "md -> pdf.",
+        mono=mono,
+    )
+
+    # ---
+
+    return "\n".join(
+        [
+            usage_1,
+            usage_2,
+        ]
+    )
+
+
+help_functions = {
+    "convert": help_convert,
+}

bluer_objects/help/upload.py

@@ -3,16 +3,23 @@ from typing import List
 from bluer_options.terminal import show_usage, xtra
 
 
+def options(mono: bool) -> str:
+    return "".join(
+        [
+            "filename=<filename>",
+            xtra(",public,zip", mono=mono),
+        ]
+    )
+
+
 def help_upload(
     tokens: List[str],
     mono: bool,
 ) -> str:
-    options = "filename=<filename>"
-
     return show_usage(
         [
             "@upload",
-            f"[{options}]",
+            f"[{options(mono=mono)}]",
             "[.|<object-name>]",
         ],
         "upload <object-name>.",

bluer_objects/help/web.py

@@ -0,0 +1,38 @@
+from typing import List
+
+from bluer_options.terminal import show_usage
+
+
+def help_is_accessible(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@web",
+            "is_accessible",
+            "<url>",
+        ],
+        "is <url> accessible?",
+        mono=mono,
+    )
+
+
+def help_where_am_i(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@web",
+            "where_am_i",
+        ],
+        "where am I?",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "is_accessible": help_is_accessible,
+    "where_am_i": help_where_am_i,
+}

bluer_objects/host/functions.py

@@ -11,7 +11,7 @@ NAME = module.name(__file__, NAME)
 
 
 def shell(
-    command: str,
+    command: Union[str, List[str]],
     clean_after: bool = False,
     return_output: bool = False,
     work_dir: str = ".",
@@ -20,6 +20,9 @@ def shell(
     bool,
     Tuple[bool, List[str]],
 ]:
+    if isinstance(command, list):
+        command = " ".join(command)
+
     if log:
         logger.info(f"{NAME}.shell({command})")
 

bluer_objects/logger/confusion_matrix.py

@@ -0,0 +1,76 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import List
+
+from bluer_objects.graphics.signature import justify_text
+from bluer_objects import file
+
+
+def log_confusion_matrix(
+    confusion_matrix: np.ndarray,
+    filename: str,
+    header: List[str] = [],
+    footer: List[str] = [],
+    x_classes: List[str] = [],
+    y_classes: List[str] = [],
+    x_name: str = "prediction",
+    y_name: str = "label",
+    line_width: int = 80,
+    log: bool = True,
+    figsize: tuple = (10, 10),
+) -> bool:
+    fig, ax = plt.subplots(figsize=figsize)
+    cax = ax.imshow(
+        confusion_matrix,
+        interpolation="nearest",
+        cmap=plt.cm.Blues,
+    )
+    fig.colorbar(cax)
+    ax.set_title(
+        justify_text(
+            " | ".join(header),
+            line_width=line_width,
+            return_str=True,
+        )
+    )
+    ax.set_xlabel(
+        justify_text(
+            " | ".join([x_name] + footer),
+            line_width=line_width,
+            return_str=True,
+        )
+    )
+    ax.set_ylabel(y_name)
+
+    if not x_classes:
+        x_classes = [f"class #{index}" for index in range(confusion_matrix.shape[1])]
+    if not y_classes:
+        y_classes = [f"class #{index}" for index in range(confusion_matrix.shape[0])]
+
+    ax.set_xticks(np.arange(confusion_matrix.shape[1]))
+    ax.set_yticks(np.arange(confusion_matrix.shape[0]))
+    ax.set_xticklabels(
+        x_classes,
+        rotation=45,
+        ha="right",
+    )
+    ax.set_yticklabels(y_classes)
+
+    threshold = confusion_matrix.max() / 2.0
+    for i in range(confusion_matrix.shape[0]):
+        for j in range(confusion_matrix.shape[1]):
+            ax.text(
+                j,
+                i,
+                f"{100*confusion_matrix[i, j]:.1f}%",
+                ha="center",
+                va="center",
+                color="white" if confusion_matrix[i, j] > threshold else "black",
+            )
+
+    plt.tight_layout()
+
+    return file.save_fig(
+        filename,
+        log=log,
+    )

bluer_objects/logger/image.py

@@ -0,0 +1,110 @@
+import matplotlib.pyplot as plt
+from typing import Dict, Any, Union, List
+import pandas as pd
+import random
+import os
+
+from bluer_options import string
+
+from bluer_objects import file, objects, path
+from bluer_objects.graphics.signature import sign_filename
+
+LOG_IMAGE_GRID_COLS = 5
+LOG_IMAGE_GRID_ROWS = 3
+
+
+def log_image_grid(
+    items: Union[
+        List[Dict[str, Any]],
+        pd.DataFrame,
+    ],
+    filename: str,
+    rows: int = LOG_IMAGE_GRID_ROWS,
+    cols: int = LOG_IMAGE_GRID_COLS,
+    log: bool = True,
+    verbose: bool = False,
+    scale: int = 2,
+    shuffle: bool = False,
+    header: List[str] = [],
+    footer: List[str] = [],
+    relative_path: bool = False,
+) -> bool:
+    if isinstance(items, pd.DataFrame):
+        items = items.to_dict("records")
+
+    while len(items) < rows * cols:
+        items += [{"pass": True}]
+    if shuffle:
+        random.shuffle(items)
+
+    items = items[: rows * cols]
+
+    if relative_path:
+        root_path = file.path(filename)
+        for item in items:
+            if item.get("filename", ""):
+                item["filename"] = os.path.join(
+                    root_path,
+                    item["filename"],
+                )
+
+    _, axes = plt.subplots(
+        rows,
+        cols,
+        figsize=(
+            scale * cols,
+            scale * rows,
+        ),
+    )
+    axes = axes.flatten()
+
+    image_shape = ""
+    for i, item in enumerate(items):
+        if item.get("pass", False):
+            axes[i].axis("off")
+            continue
+
+        if item.get("filename", ""):
+            success, item["image"] = file.load_image(
+                item.get("filename", ""),
+                log=verbose,
+            )
+            if not success:
+                return False
+
+        ax = axes[i]
+        image = item["image"]
+        image_shape = string.pretty_shape_of_matrix(image)
+        ax.imshow(
+            image,
+            cmap="gray" if image.ndim == 2 else None,
+        )
+        ax.set_title(
+            item.get("title", f"#{i}"),
+            color=item.get("color", "black"),
+            fontsize=10,
+        )
+        ax.axis("off")
+
+    plt.tight_layout()
+
+    if not file.save_fig(
+        filename,
+        log=verbose,
+    ):
+        return False
+
+    return sign_filename(
+        filename,
+        [
+            " | ".join(
+                objects.signature(
+                    info=file.name_and_extension(filename),
+                    object_name=path.name(file.path(filename)),
+                )
+                + [image_shape]
+                + header
+            )
+        ],
+        [" | ".join(footer)],
+    )

bluer_objects/logger/stitch.py

@@ -0,0 +1,107 @@
+from typing import List
+import numpy as np
+
+from blueness import module
+from bluer_options import string
+
+from bluer_objects import NAME
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def stitch_images(
+    list_of_images: List[np.ndarray],
+    cols: int = -1,
+    rows: int = -1,
+    log: bool = False,
+) -> np.ndarray:
+    if not list_of_images:
+        return np.zeros((1, 1, 3), dtype=np.uint8)
+
+    list_of_images = list_of_images.copy()
+
+    if rows == -1:
+        rows = int(np.floor(np.sqrt(len(list_of_images))))
+        cols = -1
+
+    if cols == -1:
+        cols = int(np.ceil(len(list_of_images) / rows))
+
+    if log:
+        logger.info(
+            "{}.stitch_images[{}x{}]({}): {}".format(
+                NAME,
+                rows,
+                cols,
+                len(list_of_images),
+                ", ".join(
+                    [string.pretty_shape_of_matrix(image) for image in list_of_images]
+                ),
+            )
+        )
+
+    for image in list_of_images:
+        if len(image.shape) == 2:
+            image = np.stack([image, image, image], axis=2)
+
+    if rows == 1:
+        output = np.zeros(
+            (
+                max([image.shape[0] for image in list_of_images]),
+                sum([image.shape[1] for image in list_of_images]),
+                3,
+            ),
+            dtype=np.uint8,
+        )
+        x: int = 0
+        for image in list_of_images:
+            x_new = x + image.shape[1]
+
+            output[
+                : image.shape[0],
+                x:x_new,
+                :,
+            ] = image
+
+            x = x_new
+
+        return output
+
+    if cols == 1:
+        output = np.zeros(
+            (
+                sum([image.shape[0] for image in list_of_images]),
+                max([image.shape[1] for image in list_of_images]),
+                3,
+            ),
+            dtype=np.uint8,
+        )
+        y: int = 0
+        for image in list_of_images:
+            y_new = y + image.shape[0]
+
+            output[
+                y:y_new,
+                : image.shape[1],
+                :,
+            ] = image
+
+            y = y_new
+
+        return output
+
+    return stitch_images(
+        list_of_images=[
+            stitch_images(
+                list_of_images[row * cols : (row + 1) * cols],
+                cols=cols,
+                rows=1,
+                log=log,
+            )
+            for row in range(rows)
+        ],
+        cols=1,
+        rows=rows,
+        log=log,
+    )

bluer_objects/markdown.py

@@ -12,6 +12,7 @@ NAME = module.name(__file__, NAME)
 def generate_table(
     items: List[str],
     cols: int = 3,
+    log: bool = True,
 ) -> List[str]:
     if not items:
         return []
@@ -22,13 +23,14 @@ def generate_table(
 
     row_count = int(math.ceil(len(items) / cols))
 
-    logger.info(
-        "{}.generate_table(): {} item(s), {} row(s)".format(
-            NAME,
-            len(items),
-            row_count,
+    if log:
+        logger.info(
+            "{}.generate_table(): {} item(s), {} row(s)".format(
+                NAME,
+                len(items),
+                row_count,
+            )
         )
-    )
 
     return [
         "| {} |".format(" | ".join(cols * [" "])),

bluer_objects/metadata/__init__.py

@@ -5,4 +5,5 @@ from bluer_objects.metadata.get import (
     get_from_object,
     get_from_path,
 )
+from bluer_objects.metadata.flatten import flatten
 from bluer_objects.metadata.post import post, post_to_file, post_to_object, post_to_path

bluer_objects/metadata/flatten.py

@@ -0,0 +1,27 @@
+from typing import Any
+import numpy as np
+
+
+def flatten(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return {k: flatten(v) for k, v in obj.items()}
+
+    if isinstance(obj, list):
+        return [flatten(x) for x in obj]
+
+    if isinstance(obj, tuple):
+        return tuple(flatten(x) for x in obj)
+
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+
+    if hasattr(obj, "__dict__"):
+        return flatten(vars(obj))
+
+    if isinstance(obj, (int, float, str)):
+        return obj
+
+    try:
+        return str(obj)
+    except:
+        return obj.__class__.__name__

bluer_objects/mlflow/lock/__init__.py

@@ -0,0 +1 @@
+

bluer_objects/mlflow/lock/__main__.py

@@ -0,0 +1,58 @@
+import argparse
+
+from blueness import module
+from blueness.argparse.generic import sys_exit
+
+from bluer_objects import NAME
+from bluer_objects.mlflow.lock.functions import lock, unlock
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    help="lock | unlock",
+)
+parser.add_argument(
+    "--object_name",
+    type=str,
+)
+parser.add_argument(
+    "--lock",
+    type=str,
+    default="lock",
+)
+parser.add_argument(
+    "--timeout",
+    type=int,
+    default=-1,
+    help="in seconds",
+)
+parser.add_argument(
+    "--verbose",
+    type=int,
+    default=1,
+    help="0 | 1",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "lock":
+    success = lock(
+        object_name=args.object_name,
+        lock_name=args.lock,
+        timeout=args.timeout,
+        verbose=args.verbose == 1,
+    )
+elif args.task == "unlock":
+    success = unlock(
+        object_name=args.object_name,
+        lock_name=args.lock,
+        verbose=args.verbose == 1,
+    )
+else:
+    success = None
+
+sys_exit(logger, NAME, args.task, success)