dsa_helpers 3.2.1__py3-none-any.whl

dsa_helpers/__init__.py

@@ -0,0 +1,9 @@
+# Shadow imports.
+from .imread import imread
+from .imwrite import imwrite
+
+# Version of the dsa-helpers package
+__version__ = "3.2.1"
+
+# To avoid slow downs, do not allow from dsa_helpers import * to import anything.
+__all__ = []

dsa_helpers/cli_utils.py

@@ -0,0 +1,183 @@
+from collections import deque
+import psutil, threading, time
+import numpy as np
+
+
+class SystemMonitor:
+    def __init__(self, interval=0.5):
+        self.interval = interval
+        self.cpu_percentages = deque(maxlen=100)
+        self.memory_usage = deque(maxlen=100)
+        self.io_wait = deque(maxlen=100)
+        self.cpu_per_core = deque(maxlen=100)  # Track per-core usage
+        self.memory_bandwidth = deque(maxlen=100)
+        self.io_stats = deque(maxlen=100)
+        self.stop_flag = False
+        self.process = psutil.Process()
+
+    def start(self):
+        self.stop_flag = False
+        self.monitor_thread = threading.Thread(target=self._monitor)
+        self.monitor_thread.start()
+
+    def stop(self):
+        self.stop_flag = True
+        self.monitor_thread.join()
+
+        # Calculate statistics with safety checks
+        cpu_stats = {
+            "mean": (
+                np.mean(self.cpu_percentages)
+                if len(self.cpu_percentages) > 0
+                else 0
+            ),
+            "max": (
+                np.max(self.cpu_percentages)
+                if len(self.cpu_percentages) > 0
+                else 0
+            ),
+            "min": (
+                np.min(self.cpu_percentages)
+                if len(self.cpu_percentages) > 0
+                else 0
+            ),
+            "per_core_mean": (
+                np.mean(self.cpu_per_core, axis=0)
+                if len(self.cpu_per_core) > 0
+                else np.zeros(psutil.cpu_count())
+            ),
+            "per_core_max": (
+                np.max(self.cpu_per_core, axis=0)
+                if len(self.cpu_per_core) > 0
+                else np.zeros(psutil.cpu_count())
+            ),
+            "active_cores_mean": (
+                np.mean(
+                    [
+                        sum(1 for x in cores if x > 10)
+                        for cores in self.cpu_per_core
+                    ]
+                )
+                if len(self.cpu_per_core) > 0
+                else 0
+            ),
+        }
+
+        mem_stats = {
+            "mean": (
+                np.mean(self.memory_usage) if len(self.memory_usage) > 0 else 0
+            ),
+            "max": (
+                np.max(self.memory_usage) if len(self.memory_usage) > 0 else 0
+            ),
+            "min": (
+                np.min(self.memory_usage) if len(self.memory_usage) > 0 else 0
+            ),
+        }
+
+        io_stats = {
+            "wait_mean": np.mean(self.io_wait) if len(self.io_wait) > 0 else 0,
+            "wait_max": np.max(self.io_wait) if len(self.io_wait) > 0 else 0,
+            "throughput_read": (
+                np.mean(
+                    [
+                        sum(disk["read_bytes"] for disk in x["disk"].values())
+                        / x["time_delta"]
+                        for x in self.io_stats
+                    ]
+                )
+                / 1024
+                / 1024
+                if len(self.io_stats) > 0
+                else 0
+            ),
+            "throughput_write": (
+                np.mean(
+                    [
+                        sum(disk["write_bytes"] for disk in x["disk"].values())
+                        / x["time_delta"]
+                        for x in self.io_stats
+                    ]
+                )
+                / 1024
+                / 1024
+                if len(self.io_stats) > 0
+                else 0
+            ),
+            "network_read": (
+                np.mean(
+                    [
+                        x["network"]["bytes_recv"] / x["time_delta"]
+                        for x in self.io_stats
+                    ]
+                )
+                / 1024
+                / 1024
+                if len(self.io_stats) > 0
+                else 0
+            ),
+            "network_write": (
+                np.mean(
+                    [
+                        x["network"]["bytes_sent"] / x["time_delta"]
+                        for x in self.io_stats
+                    ]
+                )
+                / 1024
+                / 1024
+                if len(self.io_stats) > 0
+                else 0
+            ),
+        }
+
+        return {"cpu": cpu_stats, "memory": mem_stats, "io": io_stats}
+
+    def _monitor(self):
+        last_io = psutil.disk_io_counters(perdisk=True)  # Monitor per-disk
+        last_net = psutil.net_io_counters()  # Add network monitoring
+        last_time = time.time()
+
+        while not self.stop_flag:
+            # CPU usage (overall and per-core)
+            per_core = psutil.cpu_percent(percpu=True)
+            self.cpu_percentages.append(np.mean(per_core))
+            self.cpu_per_core.append(per_core)
+
+            # Memory usage
+            mem = self.process.memory_info()
+            self.memory_usage.append(mem.rss / 1024 / 1024)  # Convert to MB
+
+            # IO wait and throughput
+            cpu_times = psutil.cpu_times_percent()
+            self.io_wait.append(cpu_times.iowait)
+
+            # Enhanced IO monitoring
+            current_io = psutil.disk_io_counters(perdisk=True)
+            current_net = psutil.net_io_counters()
+            current_time = time.time()
+
+            # Calculate both disk and network throughput
+            delta_time = current_time - last_time
+            io_delta = {
+                "disk": {
+                    disk: {
+                        "read_bytes": current_io[disk].read_bytes
+                        - last_io[disk].read_bytes,
+                        "write_bytes": current_io[disk].write_bytes
+                        - last_io[disk].write_bytes,
+                    }
+                    for disk in current_io
+                },
+                "network": {
+                    "bytes_recv": current_net.bytes_recv - last_net.bytes_recv,
+                    "bytes_sent": current_net.bytes_sent - last_net.bytes_sent,
+                },
+                "time_delta": delta_time,
+            }
+            self.io_stats.append(io_delta)
+
+            last_io = current_io
+            last_net = current_net
+            last_time = current_time
+
+            time.sleep(self.interval)

dsa_helpers/dash/__init__.py

@@ -0,0 +1,3 @@
+from . import header
+
+__all__ = []

dsa_helpers/dash/dash_paperdragon_utils.py

@@ -0,0 +1,76 @@
+def format_ann_docs_for_paperjs(
+    geojson_ann_docs: list[dict], return_as_input_to_paper: bool = False
+) -> list[dict]:
+    """Format DSA annotations in the geojson format into a format that paperdragon
+    can read and show as polygons.
+
+    Args:
+        geojson_ann_docs (list[dict]): A list of geojson annotation documents.
+        return_as_input_to_paper (bool): Whether to return the formatted documents as
+            input to paper. Defaults to False.
+
+    Returns:
+        list[dict]: A list of formatted annotation documents for paperjs. Note that
+            it will return an empty list if the documents could not be formatted.
+
+    """
+    # NOTE: hard-coded to only do the first doc.
+    formatted_docs = []
+
+    # Loop through each annotation document.
+    for ann_doc in geojson_ann_docs:
+        # Grab the features of this document, contains the polygon info.
+        features_to_include = []
+
+        for feature in ann_doc["features"]:
+            geometry = feature["geometry"]
+            if geometry["type"] == "Polygon":
+                properties = feature["properties"]
+                properties["rescale"] = {"strokeWidth": properties["lineWidth"]}
+                properties["strokeColor"] = properties["lineColor"]
+                properties["source"] = "dsa"
+
+                # Paperjs only supports multipolygons.
+                geometry["type"] = "MultiPolygon"
+
+                coordinates = geometry["coordinates"]
+
+                adjusted_coordinates = [
+                    [[[int(coord) for coord in point[:2]] for point in coordinates[0]]]
+                ]
+
+                geometry["coordinates"] = adjusted_coordinates
+
+                features_to_include.append(feature)
+
+        if len(features_to_include):
+            formatted_docs.append(features_to_include)
+
+    if return_as_input_to_paper:
+        return get_input_to_paper_dict(formatted_docs)
+
+    return formatted_docs
+
+
+def get_input_to_paper_dict(formatted_docs: list[dict] | None = None) -> dict:
+    """Get the input to paper dictionary.
+
+    Args:
+        formatted_docs (list[dict]): A list of formatted annotation documents for paperjs.
+
+    Returns:
+        dict: The input to paper dictionary.
+
+    """
+    input_to_paper = [{"type": "clearItems"}]
+
+    if formatted_docs is not None and len(formatted_docs):
+        for doc in formatted_docs:
+            input_to_paper.append(
+                {
+                    "type": "drawItems",
+                    "itemList": doc,
+                }
+            )
+
+    return {"actions": input_to_paper}

dsa_helpers/dash/header.py

@@ -0,0 +1,155 @@
+from dash import html, dcc
+import dash_bootstrap_components as dbc
+from .header_callbacks import get_callbacks
+
+
+def get_header(
+    dsa_api_url: str,
+    title: str = "App",
+    store_id: str = "user-store",
+    config: dict | None = None,
+) -> html.Div:
+    """Get the Dash html component that contains the header of the application
+    with login capabilities.
+
+    Args:
+        dsa_api_url (str): The URL of the DSA API.
+        title (str, optional): The title of the application. Defaults to "App".
+        config (dict, optional): The configuration of the component.
+            Defaults to None which uses default settings.
+
+    Returns:
+        html.Div: The header component.
+
+    """
+    if config is None:
+        config = {}
+
+    get_callbacks(dsa_api_url, store_id)
+
+    login_modal = dbc.Modal(
+        [
+            dbc.ModalHeader("Log in"),
+            dbc.ModalBody(
+                [
+                    html.Div(
+                        "Login or email",
+                        style={"margin": 5, "fontWeight": "bold"},
+                    ),
+                    dbc.Input(
+                        id=f"{store_id}=login",
+                        type="text",
+                        placeholder="Enter login",
+                        style={"margin": 5},
+                    ),
+                    html.Div(
+                        "Password",
+                        style={
+                            "margin": 5,
+                            "marginTop": 15,
+                            "fontWeight": "bold",
+                        },
+                    ),
+                    dbc.Input(
+                        id=f"{store_id}=password",
+                        type="password",
+                        placeholder="Enter password",
+                        style={"margin": 5},
+                    ),
+                    html.Div(
+                        "Login failed.",
+                        hidden=True,
+                        id=f"{store_id}=login-failed",
+                        style={
+                            "color": "red",
+                            "fontWeight": "bold",
+                            "margin": 10,
+                        },
+                    ),
+                ],
+            ),
+            dbc.ModalFooter(
+                dbc.Row(
+                    [
+                        dbc.Col(
+                            dbc.Button(
+                                "Close",
+                                id=f"{store_id}=close-login-modal",
+                                className="me-1",
+                                color="light",
+                            )
+                        ),
+                        dbc.Col(
+                            dbc.Button(
+                                "Login",
+                                id=f"{store_id}=log-in-btn",
+                                className="me-1",
+                                color="primary",
+                            )
+                        ),
+                    ],
+                )
+            ),
+        ],
+        is_open=False,
+        id=f"{store_id}=login-modal",
+    )
+
+    logout_modal = dbc.Modal(
+        [
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Log out",
+                        id=f"{store_id}=logout-btn",
+                        color="danger",
+                        className="me-1",
+                    ),
+                ]
+            )
+        ],
+        is_open=False,
+        id=f"{store_id}=logout-modal",
+    )
+
+    return html.Div(
+        [
+            dbc.Row(
+                [
+                    dbc.Col(
+                        html.H1(
+                            title,
+                            style={
+                                "fontWeight": "bold",
+                                "color": config.get("titleColor", "#d9d9d6"),
+                                "marginLeft": 5,
+                            },
+                        ),
+                        width="auto",
+                    ),
+                    dbc.Col(
+                        dbc.Button(
+                            "Log in",
+                            id=f"{store_id}=login-btn",
+                            color=config.get("backgroundColor", "#012169"),
+                            style={
+                                "color": config.get("fontColor", "#f2a900"),
+                                "fontSize": "1.2rem",
+                            },
+                            className="me-1",
+                        ),
+                        width="auto",
+                    ),
+                ],
+                justify="between",
+                align="center",
+            ),
+            login_modal,
+            logout_modal,
+            dcc.Store(id=store_id, storage_type="local", data={}),
+        ],
+        style={
+            "backgroundColor": config.get("backgroundColor", "#012169"),
+            "padding": 5,
+        },
+    )

dsa_helpers/dash/header_callbacks.py

@@ -0,0 +1,99 @@
+# Callbacks for the header component.
+from dash import callback, Output, Input, State, no_update
+from girder_client import GirderClient
+
+
+def get_callbacks(dsa_api_url: str, store_id: str):
+    """Setup the callbacks to the DSA API url of interest and the proper store id."""
+
+    @callback(Output(f"{store_id}=login-btn", "children"), Input(store_id, "data"))
+    def check_user_store(data):
+        # Check if the user store has user info or if no one is logged in.
+        return data["user"] if len(data) else "Log in"
+
+    @callback(
+        [
+            Output(f"{store_id}=login-modal", "is_open", allow_duplicate=True),
+            Output(f"{store_id}=logout-modal", "is_open", allow_duplicate=True),
+        ],
+        [
+            Input(f"{store_id}=login-btn", "n_clicks"),
+            State(f"{store_id}=login-btn", "children"),
+        ],
+        prevent_initial_call=True,
+    )
+    def open_login_modal(n_clicks, children):
+        # Open login / logout modal.
+        if n_clicks:
+            if children == "Log in":
+                return True, False
+            else:
+                return False, True
+
+        return False, False
+
+    @callback(
+        [
+            Output(store_id, "data"),
+            Output(f"{store_id}=login-failed", "hidden", allow_duplicate=True),
+            Output(f"{store_id}=login-modal", "is_open", allow_duplicate=True),
+            Output(f"{store_id}=login", "value", allow_duplicate=True),
+            Output(f"{store_id}=password", "value", allow_duplicate=True),
+        ],
+        [
+            Input(f"{store_id}=log-in-btn", "n_clicks"),
+            State(f"{store_id}=login", "value"),
+            State(f"{store_id}=password", "value"),
+        ],
+        prevent_initial_call=True,
+    )
+    def login(n_clicks, login, password):
+        # Try to login.
+        gc = GirderClient(apiUrl=dsa_api_url)
+
+        try:
+            _ = gc.authenticate(username=login, password=password)
+
+            response = gc.get("token/session")
+
+            user = gc.get("user/me")["login"]
+
+            return {"user": user, "token": response["token"]}, True, False, "", ""
+        except:
+            return (
+                {},
+                False,
+                True,
+                no_update,
+                no_update,
+            )
+
+    @callback(
+        [
+            Output(f"{store_id}=login-modal", "is_open", allow_duplicate=True),
+            Output(f"{store_id}=login", "value", allow_duplicate=True),
+            Output(f"{store_id}=password", "value", allow_duplicate=True),
+            Output(f"{store_id}=login-failed", "hidden", allow_duplicate=True),
+        ],
+        Input(f"{store_id}=close-login-modal", "n_clicks"),
+        prevent_initial_call=True,
+    )
+    def close_login_modal(n_clicks):
+        if n_clicks:
+            return False, "", "", True
+
+        return False, "", "", True
+
+    @callback(
+        [
+            Output(store_id, "data", allow_duplicate=True),
+            Output(f"{store_id}=logout-modal", "is_open", allow_duplicate=True),
+        ],
+        Input(f"{store_id}=logout-btn", "n_clicks"),
+        prevent_initial_call=True,
+    )
+    def logout(n_clicks):
+        if n_clicks:
+            return {}, False
+
+        return no_update, False