bear-utils 0.0.1__py3-none-any.whl

bear_utils/monitoring/host_monitor.py

@@ -0,0 +1,346 @@
+"""Host Monitor Module."""
+
+import asyncio
+from asyncio import Task
+from collections import deque
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+from dataclasses import dataclass
+import subprocess
+from typing import TYPE_CHECKING, Literal, Self, TypedDict, cast, overload
+
+from bear_utils.logger_manager import get_console
+from bear_utils.monitoring._common import CPU, CPU_MEM, DISK, GPU, MEM, TaskChoice
+
+ROLLING_AVERAGE_TIME = 300
+
+if TYPE_CHECKING:
+    from subprocess import CompletedProcess
+
+_base_logger, console = get_console("HostMonitor")
+
+
+def has_nvidia_gpu() -> bool:
+    """Check if the system has an NVIDIA GPU."""
+    try:
+        result = subprocess.run(
+            check=False,
+            args=["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0
+    except Exception as e:
+        console.error(f"Error checking for NVIDIA GPU: {e}", exc_info=True)
+        return False
+
+
+@dataclass(slots=True)
+class GPUSamples:
+    """GPU samples for monitoring."""
+
+    gpu_usage: float = 0.0
+    gpu_mem_usage: float = 0.0
+    gpu_mem_total: float = 0.0
+    gpu_mem_free: float = 0.0
+
+    def __post_init__(self) -> None:
+        if self.gpu_mem_total == 0:
+            self.gpu_mem_total = self.gpu_mem_usage + self.gpu_mem_free
+
+    @classmethod
+    async def get_gpu_samples(cls) -> Self:
+        """Get GPU samples using nvidia-smi."""
+        try:
+            result: CompletedProcess[str] = subprocess.run(
+                check=False,
+                args=[
+                    "nvidia-smi",
+                    "--query-gpu=utilization.gpu,memory.used,memory.total,memory.free",
+                    "--format=csv,noheader",
+                ],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                console.error(f"nvidia-smi command failed with return code {result.returncode}")
+                return cls()
+            gpu_usage, gpu_mem_used, gpu_mem_total, gpu_mem_free = map(float, result.stdout.split(","))
+            return cls(
+                gpu_usage=gpu_usage,
+                gpu_mem_usage=gpu_mem_used,
+                gpu_mem_total=gpu_mem_total,
+                gpu_mem_free=gpu_mem_free,
+            )
+        except Exception as e:
+            console.error(f"Error getting GPU samples: {e}", exc_info=True)
+            return cls()
+
+
+@dataclass(slots=True)
+class HostMonitorResult:
+    """Result class for host monitoring."""
+
+    # CPU
+    cpu_usage_avg: float = 0.0
+    cpu_max: float = 0.0
+    cpu_min: float = 0.0
+
+    mem_usage_avg: float = 0.0
+    mem_max: float = 0.0
+    mem_min: float = 0.0
+
+    disk_usage_avg: float = 0.0
+
+    gpu_usage_avg: float = 0.0
+    gpu_usage_max: float = 0.0
+    gpu_usage_min: float = 0.0
+
+    gpu_mem_usage_avg: float = 0.0
+    gpu_mem_usage_max: float = 0.0
+    gpu_mem_usage_min: float = 0.0
+
+    @property
+    def empty(self) -> bool:
+        """Check if the result is empty."""
+        return not self.has_cpu_data and not self.has_mem_data and not self.has_disk_data and not self.has_gpu_data
+
+    @property
+    def has_cpu_data(self) -> bool:
+        """Check if CPU data is available."""
+        return self.cpu_usage_avg != 0.0 or self.cpu_max != 0.0 or self.cpu_min != 0.0
+
+    @property
+    def has_mem_data(self) -> bool:
+        """Check if memory data is available."""
+        return self.mem_usage_avg != 0.0 or self.mem_max != 0.0 or self.mem_min != 0.0
+
+    @property
+    def has_disk_data(self) -> bool:
+        """Check if disk data is available."""
+        return self.disk_usage_avg != 0.0
+
+    @property
+    def has_gpu_data(self) -> bool:
+        """Check if GPU data is available."""
+        return (
+            self.gpu_usage_avg != 0.0
+            or self.gpu_usage_max != 0.0
+            or self.gpu_usage_min != 0.0
+            or self.gpu_mem_usage_avg != 0.0
+        )
+
+
+class SampleStore(TypedDict):
+    """TypedDict for storing samples and getter function."""
+
+    samples: deque[float | GPUSamples]
+    getter: Callable[[], Awaitable[float | GPUSamples]]
+
+
+class HostMonitor:
+    """Host Monitor for collecting and averaging system metrics."""
+
+    def __init__(self, sample_interval: float = 1, tasks: tuple = CPU_MEM):
+        """Initialize the HostMonitor with specified tasks and sample interval."""
+        self.console = console
+        self.disk_path = "/"
+        self.sample_stores: dict[TaskChoice, SampleStore] = {}
+        self.tasks: list[TaskChoice] = list(tasks)
+
+        if self.is_task_enabled(TaskChoice.GPU) and not has_nvidia_gpu():
+            self.tasks.remove(TaskChoice.GPU)
+            self.console.warning("No NVIDIA GPU detected, removing GPU task from monitoring.")
+
+        self.sample_stores = {
+            task: {
+                "samples": deque(maxlen=int(ROLLING_AVERAGE_TIME // sample_interval)),
+                "getter": getattr(self, f"get_{task.value}"),
+            }
+            for task in tasks
+        }
+
+        self.sampling_task: Task | None = None
+        self.is_monitoring: bool = False
+        self.sample_interval: float = sample_interval
+        self.last_result = HostMonitorResult()
+
+        self.console.verbose("HostMonitor initialized")
+
+    def is_task_enabled(self, task: TaskChoice) -> bool:
+        """Check if a specific task is enabled."""
+        return task in self.tasks
+
+    async def start(self) -> None:
+        """Start the host monitoring."""
+        self.is_monitoring = True
+        self.sampling_task = asyncio.create_task(self._collect_samples())
+
+    async def stop(self) -> None:
+        """Stop the host monitoring."""
+        self.is_monitoring = False
+        if self.sampling_task:
+            self.sampling_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self.sampling_task
+        self.sampling_task = None
+
+    async def clear(self) -> None:
+        """Clear all samples from the sample stores."""
+        for store in self.sample_stores.values():
+            store["samples"].clear()
+
+    @overload
+    async def get(self, task: Literal[TaskChoice.CPU, TaskChoice.MEM, TaskChoice.DISK]) -> float: ...
+
+    @overload
+    async def get(self, task: Literal[TaskChoice.GPU]) -> GPUSamples: ...
+
+    async def get(self, task: TaskChoice) -> float | GPUSamples:
+        """Manually get a sample for the specified task."""
+        getter_func = self.sample_stores[task]["getter"]
+        if getter_func is None:
+            self.console.error(f"Getter method for task {task} is None.")
+            return 0.0
+        result: float | GPUSamples | None = await getter_func()
+        if result is not None:
+            if isinstance(result, GPUSamples):
+                return result
+            return float(result)
+        return 0.0
+
+    async def _collect_samples(self) -> None:
+        await self.clear()
+        while self.is_monitoring:
+            await self._record_data()
+            await asyncio.sleep(self.sample_interval)
+
+    async def _record_data(self) -> None:
+        for task in self.tasks:
+            getter_func = self.sample_stores[task]["getter"]
+            if getter_func is None:
+                self.console.error(f"Getter method for task {task} is None.")
+                continue
+            result: float | GPUSamples | None = await getter_func()
+            if result is not None:
+                self.sample_stores[task]["samples"].append(result)
+
+    @overload
+    async def _get_samples(self, task: Literal[TaskChoice.CPU, TaskChoice.MEM, TaskChoice.DISK]) -> list[float]: ...
+
+    @overload
+    async def _get_samples(self, task: Literal[TaskChoice.GPU]) -> list[GPUSamples]: ...
+
+    async def _get_samples(self, task: TaskChoice) -> list[float] | list[GPUSamples]:
+        """Get collected samples for the specified task."""
+        if not self.is_monitoring or not self.sample_stores.get(task):
+            return [0.0]
+        try:
+            sample = list(self.sample_stores[task]["samples"])
+            return cast("list[GPUSamples]", sample) if task == GPU else cast("list[float]", sample)
+        except Exception as e:
+            self.console.error(f"Error getting {task} samples: {e}", exc_info=True)
+            return [0.0]
+
+    async def get_sample(self, task: TaskChoice) -> float:
+        """Get a single sample for the specified task."""
+        if not self.is_monitoring or not self.sample_stores.get(task):
+            return 0.0
+        try:
+            result: list[float] | list[GPUSamples] = await self._get_samples(task)
+            if not result:
+                return 0.0
+            if task == GPU and isinstance(result[0], GPUSamples):
+                first_result: GPUSamples = result[0]
+                return first_result.gpu_usage if isinstance(first_result, GPUSamples) else 0.0
+            return result[0] if isinstance(result[0], float) else 0.0
+        except Exception as e:
+            self.console.error(f"Error getting single {task} sample: {e}", exc_info=True)
+        return 0.0
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the monitor is running."""
+        return self.is_monitoring and self.sampling_task is not None and bool(self.sample_stores)
+
+    async def get_current_samples(self) -> HostMonitorResult:
+        """Get the current samples for all tasks."""
+        result = HostMonitorResult()
+        if not self.is_running:
+            return result
+        try:
+            if self.is_task_enabled(CPU):
+                cpu_samples: list[float] = await self._get_samples(TaskChoice.CPU)
+                if cpu_samples:
+                    result.cpu_usage_avg = round(sum(cpu_samples) / len(cpu_samples), 2)
+                    result.cpu_max = max(cpu_samples)
+                    result.cpu_min = min(cpu_samples)
+            if self.is_task_enabled(MEM):
+                mem_samples: list[float] = await self._get_samples(TaskChoice.MEM)
+                if mem_samples:
+                    result.mem_usage_avg = round(sum(mem_samples) / len(mem_samples), 2)
+                    result.mem_max = max(mem_samples)
+                    result.mem_min = min(mem_samples)
+            if self.is_task_enabled(DISK):
+                disk_samples: list[float] = await self._get_samples(TaskChoice.DISK)
+                if disk_samples:
+                    result.disk_usage_avg = round(sum(disk_samples) / len(disk_samples), 2)
+            if self.is_task_enabled(GPU):
+                gpu_samples: list[GPUSamples] = await self._get_samples(TaskChoice.GPU)
+                if gpu_samples:
+                    gpu_usage: list[float] = [sample.gpu_usage for sample in gpu_samples]
+                    result.gpu_usage_avg = round(sum(gpu_usage) / len(gpu_usage), 2)
+                    result.gpu_usage_max = max(gpu_usage)
+                    result.gpu_usage_min = min(gpu_usage)
+            self.last_result: HostMonitorResult = result
+        except Exception as e:
+            self.console.error(f"Error getting current samples: {e}", exc_info=True)
+        return result
+
+    async def get_avg_cpu_temp(self) -> float:
+        """Get the average CPU temperature."""
+        if not self.is_monitoring or not self.sample_stores.get(CPU):
+            return 0.0
+        try:
+            current_cpu_samples: list[float] = await self._get_samples(TaskChoice.CPU)
+            if current_cpu_samples:
+                return round(sum(current_cpu_samples) / len(current_cpu_samples), 2)
+        except Exception as e:
+            self.console.error(f"Error getting CPU temperature: {e}", exc_info=True)
+        return 0.0
+
+    async def get_avg_mem_usage(self) -> float:
+        """Get the average memory usage."""
+        if not self.is_monitoring or not self.sample_stores.get(MEM):
+            return 0.0
+        try:
+            current_mem_samples: list[float] = await self._get_samples(TaskChoice.MEM)
+            if current_mem_samples:
+                return round(sum(current_mem_samples) / len(current_mem_samples), 2)
+        except Exception as e:
+            print(f"Error getting memory usage: {e}")
+        return 0.0
+
+    async def get_disk_usage(self) -> float:
+        """Get the average disk usage."""
+        if not self.is_monitoring or not self.sample_stores.get(DISK):
+            return 0.0
+        try:
+            current_disk_samples: list[float] = await self._get_samples(TaskChoice.DISK)
+            if current_disk_samples:
+                return round(sum(current_disk_samples) / len(current_disk_samples), 2)
+        except Exception as e:
+            print(f"Error getting disk usage: {e}")
+        return 0.0
+
+    async def get_avg_gpu_usage(self) -> float:
+        """Get the average GPU usage."""
+        if not self.is_monitoring or not self.sample_stores.get(GPU):
+            return 0.0
+        try:
+            current_gpu_samples: list[GPUSamples] = await self._get_samples(TaskChoice.GPU)
+            if current_gpu_samples:
+                return round(sum(sample.gpu_usage for sample in current_gpu_samples) / len(current_gpu_samples), 2)
+        except Exception as e:
+            print(f"Error getting GPU usage: {e}")
+        return 0.0

bear_utils/time/__init__.py

@@ -0,0 +1,59 @@
+"""A module for Bear Epoch Time utilities centering around the EpochTimestamp class."""
+
+from importlib.metadata import version
+
+from bear_epoch_time import EpochTimestamp, TimerData, TimeTools, add_ord_suffix, create_timer, timer
+from bear_epoch_time._helpers import (
+    convert_to_milliseconds,
+    convert_to_seconds,
+    seconds_to_time,
+    seconds_to_timedelta,
+    timedelta_to_seconds,
+)
+from bear_epoch_time.constants.date_related import (
+    DATE_FORMAT,
+    DATE_TIME_FORMAT,
+    DT_FORMAT_WITH_SECONDS,
+    DT_FORMAT_WITH_TZ,
+    DT_FORMAT_WITH_TZ_AND_SECONDS,
+    ET_TIME_ZONE,
+    PT_TIME_ZONE,
+    TIME_FORMAT_WITH_SECONDS,
+    UTC_TIME_ZONE,
+)
+
+
+def get_bear_epoch_time_version() -> str:
+    """Get the version of the bear_epoch_time package."""
+    try:
+        return version("bear_epoch_time")
+    except Exception:
+        return "unknown"
+
+
+__version__: str = get_bear_epoch_time_version()
+
+
+__all__ = [
+    "DATE_FORMAT",
+    "DATE_TIME_FORMAT",
+    "DT_FORMAT_WITH_SECONDS",
+    "DT_FORMAT_WITH_TZ",
+    "DT_FORMAT_WITH_TZ_AND_SECONDS",
+    "ET_TIME_ZONE",
+    "PT_TIME_ZONE",
+    "TIME_FORMAT_WITH_SECONDS",
+    "UTC_TIME_ZONE",
+    "EpochTimestamp",
+    "TimeTools",
+    "TimerData",
+    "__version__",
+    "add_ord_suffix",
+    "convert_to_milliseconds",
+    "convert_to_seconds",
+    "create_timer",
+    "seconds_to_time",
+    "seconds_to_timedelta",
+    "timedelta_to_seconds",
+    "timer",
+]

bear_utils-0.0.1.dist-info/METADATA

@@ -0,0 +1,305 @@
+Metadata-Version: 2.4
+Name: bear-utils
+Version: 0.0.1
+Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
+Author-email: chaz <bright.lid5647@fastmail.com>
+Requires-Python: >=3.12
+Requires-Dist: bear-epoch-time>=1.1.4
+Requires-Dist: diskcache<6.0.0,>=5.6.3
+Requires-Dist: fastapi>=0.116.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: pillow<12.0.0,>=11.2.1
+Requires-Dist: prompt-toolkit<4.0.0,>=3.0.51
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: pyfiglet>=1.0.3
+Requires-Dist: pyglm<3.0.0,>=2.8.2
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich<15.0.0,>=14.0.0
+Requires-Dist: singleton-base>=1.0.5
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.40
+Requires-Dist: tinydb>=4.8.2
+Requires-Dist: toml>=0.10.2
+Requires-Dist: typer>=0.16.0
+Requires-Dist: uvicorn>=0.35.0
+Provides-Extra: gui
+Requires-Dist: pyqt6>=6.9.0; extra == 'gui'
+Description-Content-Type: text/markdown
+
+# Bear Utils
+
+Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
+
+## Overview
+
+Bear Utils is a collection of utility modules I've created for common tasks across my Python projects. The library is designed to be modular and easy to use, with each component focusing on a specific functionality.
+
+## Installation
+
+```bash
+pip install bear-util.      # Core package (recommended for most users)
+pip install bear-utils[gui] # With optional GUI functionality
+
+# Using UV
+uv add bear-utils                    # Core only
+uv add bear-utils --group gui        # With GUI functionality
+```
+
+## Key Components
+
+### Cache Management
+
+The `cache` package provides disk cache functionality via `diskcache`:
+
+```python
+from bear_utils.cache import CacheWrapper, cache_factory
+
+# Create a cache instance
+cache = Cache(directory="~/.cache/my_app")
+
+# Use the cache factory to create a decorated function
+@cache_factory(directory="~/.cache/my_app")
+def expensive_function(arg1, arg2):
+    # Function will be cached based on arguments
+    pass
+```
+
+### Database Management
+
+The `database` package provides SQLAlchemy integration with helpful patterns:
+
+```python
+from bear_utils.database import DatabaseManager
+from sqlalchemy import Column, Integer, String
+
+# Get declarative base
+Base = DatabaseManager.get_base()
+
+# Define models
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+
+# Create and use database
+db = DatabaseManager("sqlite:///app.db")
+with db.session() as session:
+    session.add(User(name="test"))
+    session.commit()
+```
+
+### Logging
+
+The `logging` package provides an enhanced console logger using rich:
+
+```python
+from bear_utils.logger_manager import ConsoleLogger
+
+logger = ConsoleLogger()
+logger.info("Information message")
+logger.error("Error message") 
+logger.warning("Warning message")
+```
+
+### Time Management
+
+The `time` package contains tools for time handling and measurement:
+
+```python
+from bear_utils.time import TimeTools, EpochTimestamp
+
+# Get current timestamp
+now = EpochTimestamp()
+
+# Time function execution
+from bear_utils.time.time_manager import timer
+
+with timer(name="my_operation"):
+    # Code to measure
+    pass
+```
+
+### File Handling
+
+The `files` package provides abstractions for working with different file types:
+
+```python
+from pathlib import Path
+from bear_utils.files.file_handlers import FileHandlerFactory
+
+factory = FileHandlerFactory()
+handler = factory.get_handler(Path("config.json"))
+data = handler.read_file()
+```
+
+### Prompt Helpers
+
+Utilities for creating interactive command-line prompts:
+
+```python
+from bear_utils.cli.prompt_helpers import restricted_prompt
+
+choice = restricted_prompt(
+    message="Select an option:", 
+    valid_options=["option1", "option2"]
+)
+```
+
+### GUI Utilities (Optional)
+
+**Note: GUI functionality requires the optional PyQt6 dependency. Install with `pip install bear-utils[gui]`**
+
+The `gui` package provides PyQt6-based dialog utilities for desktop applications:
+
+```python
+# Color picker dialog
+from bear_utils.gui import select_color
+
+color_info = select_color(
+    initial_color="#FF5733", 
+    title="Choose a Color"
+)
+if color_info:
+    print(f"Selected: {color_info.hex}")  # e.g., "#FF5733"
+    print(f"RGB: {color_info.rgb}")       # ColorTriplet(255, 87, 51)
+    print(f"RGBA: {color_info.rgba}")     # (255, 87, 51, 255)
+
+# Text input dialog
+from bear_utils.gui import get_text
+
+user_input = get_text(
+    title="Input Required",
+    label="Enter your name:",
+    default="Default text"
+)
+
+# Qt Application wrapper
+from bear_utils.gui import QTApplication
+
+app = QTApplication(
+    app_name="My App",
+    org_name="My Organization"
+)
+```
+
+**Error handling**: If PyQt6 is not installed, importing GUI components will raise a helpful error:
+```
+ImportError: PyQt6 is required for GUI functionality. Install it with: pip install bear-utils[gui]
+```
+
+### Image Helpers
+
+Utilities for working with images are located in the `graphics` package:
+
+```python
+from pathlib import Path
+from bear_utils.graphics import encode_image_to_jpeg, encode_image_to_png
+
+# Encode image to base64 string
+jpeg_data = encode_image_to_jpeg(Path("image.jpg"), max_size=800)
+png_data = encode_image_to_png(Path("image.png"), max_size=800)
+```
+
+### Clipboard Helpers
+
+`bear_utils.extras._tools` includes simple helpers for interacting with the system clipboard:
+
+```python
+from bear_utils.extras._tools import copy_to_clipboard, paste_from_clipboard
+
+copy_to_clipboard("hello world")
+text = paste_from_clipboard()
+```
+
+Supported platforms include macOS (`pbcopy/pbpaste`), Windows (`clip`/`powershell Get-Clipboard`),
+and Linux with either Wayland (`wl-copy`/`wl-paste`) or X11 (`xclip`).
+
+### Gradient Utilities
+
+The `graphics.bear_gradient` module provides color gradient functionality for the purposes of visualizing data or creating color transitions:
+
+```python
+from bear_utils.graphics import ColorGradient, RichColor
+from rich.console import Console
+from rich.color_triplet import ColorTriplet
+
+console = Console()
+
+# Health meter goes from red (low health) to green (full health)
+health_gradient = ColorGradient()
+
+console.print("🏥 [bold]Health Meter Demonstration[/bold] 🏥\n")
+
+# Normal health: Red (low) -> Green (high)
+console.print("[bold green]Normal Health Levels (0% = Critical, 100% = Perfect):[/bold green]")
+for health in range(0, 101, 10):
+    color: ColorTriplet = health_gradient.map_to_color(0, 100, health)
+    health_bar = "█" * (health // 5)
+    console.print(f"HP: {health:3d}/100 {health_bar:<20}", style=color.rgb)
+
+console.print("\n" + "="*50 + "\n")
+
+# Reversed: Infection/Damage meter (Green = good, Red = bad)
+console.print("[bold red]Infection Level (0% = Healthy, 100% = Critical):[/bold red]")
+health_gradient.reverse = True
+for infection in range(0, 101, 10):
+    color: ColorTriplet = health_gradient.map_to_color(0, 100, infection)
+    infection_bar = "█" * (infection // 5)
+    status = "🦠" if infection > 70 else "⚠️" if infection > 30 else "✅"
+    console.print(f"Infection: {infection:3d}% {infection_bar:<20} {status}", style=color.rgb)
+
+health_scenarios = [
+    (5, "💀 Nearly Dead"),
+    (25, "🩸 Critical Condition"), 
+    (50, "⚠️  Wounded"),
+    (75, "😐 Recovering"),
+    (95, "💪 Almost Full Health"),
+    (100, "✨ Perfect Health")
+]
+
+console.print("[bold green]Health Status Examples:[/bold green]")
+for hp, status in health_scenarios:
+    color: ColorTriplet = health_gradient.map_to_color(0, 100, hp)
+    console.print(f"{status}: {hp}/100 HP", style=color.rgb)
+```
+
+### Event System
+
+The `events` module provides a pub/sub event system that supports both synchronous and asynchronous handlers:
+
+```python
+from bear_utils.events.events_module import subscribe, publish
+
+# Subscribe to events
+@subscribe("user_logged_in")
+def handle_login(user_id):
+    print(f"User {user_id} logged in")
+
+# Publish events
+publish("user_logged_in", 12345)
+
+# Async support
+@subscribe("data_processed")
+async def handle_process(data):
+    await process_async(data)
+
+# Clear handlers
+from bear_utils.events.events_module import clear_handlers_for_event
+clear_handlers_for_event("user_logged_in")
+```
+
+### Async Helpers
+
+The `extras/_async_helpers.py` module provides utility functions for working with async code:
+
+```python
+from bear_utils.extras._async_helpers import is_async_function
+
+def handle_function(func):
+    if is_async_function(func):
+        # Handle async function
+        pass
+    else:
+        # Handle sync function
+        pass
+```