algorhino-anemone 0.1.1__py3-none-any.whl

anemone/utils/dict_of_numbered_dict_with_pointer_on_max.py

@@ -0,0 +1,128 @@
+"""
+Module for DictOfNumberedDictWithPointerOnMax class.
+"""
+
+from typing import Protocol
+
+
+class HasTreeDepth(Protocol):
+    """Protocol for objects that have a tree_depth attribute."""
+
+    @property
+    def tree_depth(self) -> int:
+        """
+        Get the half move count of the node.
+
+        Returns:
+            The half move count of the node.
+        """
+        ...
+
+
+class DictOfNumberedDictWithPointerOnMax[T_Key: HasTreeDepth, T_Value]:
+    """
+    A dictionary-like data structure that stores numbered dictionaries and keeps track of the maximum half move.
+
+    Attributes:
+        tree_depths (dict[int, dict[T_Key, T_Value]]): A dictionary that stores numbered dictionaries.
+        max_tree_depth (int | None): The maximum half move value.
+
+    Methods:
+        __setitem__(self, node: T_Key, value: T_Value) -> None: Adds an item to the data structure.
+        __getitem__(self, node: T_Key) -> T_Value: Retrieves an item from the data structure.
+        __bool__(self) -> bool: Checks if the data structure is non-empty.
+        __contains__(self, node: T_Key) -> bool: Checks if an item is present in the data structure.
+        popitem(self) -> tuple[T_Key, T_Value]: Removes and returns the item with the maximum half move value.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the depth-indexed mapping."""
+        self.tree_depths: dict[int, dict[T_Key, T_Value]] = {}
+        self.max_tree_depth: int | None = None
+
+    def __setitem__(self, node: T_Key, value: T_Value) -> None:
+        """
+        Adds an item to the data structure.
+
+        Args:
+            node (T_Key): The key of the item.
+            value (T_Value): The value of the item.
+
+        Returns:
+            None
+        """
+        tree_depth = node.tree_depth
+        if self.max_tree_depth is None:
+            self.max_tree_depth = tree_depth
+        else:
+            self.max_tree_depth = max(tree_depth, self.max_tree_depth)
+        if tree_depth in self.tree_depths:
+            self.tree_depths[tree_depth][node] = value
+        else:
+            self.tree_depths[tree_depth] = {node: value}
+
+        assert self.max_tree_depth == max(self.tree_depths)
+
+    def __getitem__(self, node: T_Key) -> T_Value:
+        """
+        Retrieves an item from the data structure.
+
+        Args:
+            node (T_Key): The key of the item.
+
+        Returns:
+            T_Value: The value of the item.
+
+        Raises:
+            KeyError: If the item is not found in the data structure.
+        """
+        return self.tree_depths[node.tree_depth][node]
+
+    def __bool__(self) -> bool:
+        """
+        Checks if the data structure is non-empty.
+
+        Returns:
+            bool: True if the data structure is non-empty, False otherwise.
+        """
+        return bool(self.tree_depths)
+
+    def __contains__(self, node: T_Key) -> bool:
+        """
+        Checks if an item is present in the data structure.
+
+        Args:
+            node (T_Key): The key of the item.
+
+        Returns:
+            bool: True if the item is present, False otherwise.
+        """
+        if node.tree_depth not in self.tree_depths:
+            return False
+        else:
+            return node in self.tree_depths[node.tree_depth]
+
+    def popitem(self) -> tuple[T_Key, T_Value]:
+        """
+        Removes and returns the item with the maximum half move value.
+
+        Returns:
+            tuple[T_Key, T_Value]: The key-value pair of the removed item.
+
+        Raises:
+            AssertionError: If the data structure is empty.
+        """
+        assert self.max_tree_depth is not None
+        popped: tuple[T_Key, T_Value] = self.tree_depths[self.max_tree_depth].popitem()
+        if not self.tree_depths[self.max_tree_depth]:
+            del self.tree_depths[self.max_tree_depth]
+            if self.tree_depths:
+                self.max_tree_depth = max(self.tree_depths.keys())
+            else:
+                self.max_tree_depth = None
+
+        return popped
+
+    # def sort_dic(self):
+    #    self.dic = dict(sorted(self.dic.items(), key=lambda item: item[0]))
+    # {k: v for k, v in sorted(x.items(), key=lambda item: item[1])}

anemone/utils/logger.py

@@ -0,0 +1,94 @@
+# logger_module.py
+
+from contextlib import contextmanager
+from logging import DEBUG, ERROR, WARNING, Logger, getLogger
+from typing import Generator
+
+from rich.logging import RichHandler
+
+anemone_logger = getLogger("anemone_app")
+anemone_logger.setLevel(DEBUG)
+
+if not anemone_logger.handlers:
+    console_handler = RichHandler()
+    console_handler.setLevel(DEBUG)
+    anemone_logger.addHandler(console_handler)
+    anemone_logger.propagate = False
+
+
+def set_chipiron_logger_level(level: int) -> None:
+    """
+    Set the logging level for the chipiron logger and all its handlers.
+
+    This ensures that both the logger and its handlers are set to the same level,
+    so log messages at the specified level will actually be displayed.
+
+    Args:
+        level (int): The logging level to set (e.g., logging.DEBUG, logging.INFO,
+                    logging.WARNING, logging.ERROR, logging.CRITICAL)
+    """
+    anemone_logger.setLevel(level)
+    for handler in anemone_logger.handlers:
+        handler.setLevel(level)
+
+
+@contextmanager
+def suppress_logging(
+    logger: Logger, level: int = WARNING
+) -> Generator[None, None, None]:
+    """
+    Context manager to temporarily suppress logging for a specific logger to a given level.
+
+    Sets the logger's level to the specified value for the duration of the context, then restores
+    its original level afterwards. Useful for silencing output from a particular logger during
+    benchmarking or other operations.
+
+    Args:
+        logger (logging.Logger): The logger to suppress.
+        level (int): The logging level to set (e.g., logging.ERROR, logging.WARNING).
+
+    Yields:
+        None
+    """
+    previous_level = logger.level
+    logger.setLevel(level)
+    try:
+        yield
+    finally:
+        logger.setLevel(previous_level)
+
+
+# Suppress all logging from all loggers (global)
+@contextmanager
+def suppress_all_logging(level: int = ERROR) -> Generator[None, None, None]:
+    """
+    Context manager to temporarily suppress logging from all loggers to a specified level.
+
+    This sets the level of all loggers (including the root logger) to the given level for the duration
+    of the context, then restores their original levels afterwards. Useful for benchmarking or
+    situations where you want to silence all logging output temporarily.
+
+    Args:
+        level (int): The logging level to set (e.g., logging.ERROR, logging.WARNING).
+
+    Yields:
+        None
+    """
+    logger_dict = getLogger().manager.loggerDict
+    original_levels: dict[str, int] = {}
+
+    for name in logger_dict:
+        logger = getLogger(name)
+        original_levels[name] = logger.level
+        logger.setLevel(level)
+
+    root_logger = getLogger()
+    original_root_level = root_logger.level
+    root_logger.setLevel(level)
+
+    try:
+        yield
+    finally:
+        for name, original_level in original_levels.items():
+            getLogger(name).setLevel(original_level)
+        root_logger.setLevel(original_root_level)

anemone/utils/my_value_sorted_dict.py

@@ -0,0 +1,27 @@
+"""
+Module for sorting a dictionary by ascending order
+"""
+
+from typing import Any, Protocol
+
+
+class _Sortable(Protocol):
+    def __lt__(self, other: Any, /) -> bool:
+        """Return True if this object is less than the other."""
+        ...
+
+
+def sort_dic[K, V: _Sortable](dic: dict[K, V]) -> dict[K, V]:
+    """
+    Sorts a dictionary by ascending order of values.
+
+    Args:
+            dic (dict[K, V]): The dictionary to be sorted.
+
+    Returns:
+            dict[K, V]: The sorted dictionary.
+    """
+    z = dic.items()
+    a = sorted(z, key=lambda item: item[1])
+    sorted_dic = dict(a)
+    return sorted_dic

anemone/utils/small_tools.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from itertools import islice
+from math import exp
+from os import PathLike
+from typing import Annotated, List, Sequence
+
+path = Annotated[str | PathLike[str], "path"]
+
+
+def nth_key[_T, _V](dct: dict[_T, _V], n: int) -> _T:
+    """
+    Get the nth key from a dictionary.
+
+    Args:
+        dct: The dictionary.
+        n: The index of the key to retrieve.
+
+    Returns:
+        The nth key from the dictionary.
+
+    """
+    it = iter(dct)
+    # Consume n elements.
+    next(islice(it, n, n), None)
+    # Return the value at the current position.
+    # This raises StopIteration if n is beyond the limits.
+    # Use next(it, None) to suppress that exception.
+    return next(it)
+
+
+@dataclass
+class Interval:
+    """
+    Represents an interval with a minimum and maximum value.
+    """
+
+    min_value: float | None = None
+    max_value: float | None = None
+
+
+def intersect_intervals(interval_1: Interval, interval_2: Interval) -> Interval | None:
+    """
+    Find the intersection of two intervals.
+
+    Args:
+        interval_1: The first interval.
+        interval_2: The second interval.
+
+    Returns:
+        The intersection of the two intervals, or None if there is no intersection.
+
+    Raises:
+        AssertionError: If any of the intervals have missing values.
+
+    """
+    assert interval_1.max_value is not None and interval_1.min_value is not None
+    assert interval_2.max_value is not None and interval_2.min_value is not None
+    min_value: float = max(interval_1.min_value, interval_2.min_value)
+    max_value: float = min(interval_1.max_value, interval_2.max_value)
+    if max_value < min_value:
+        return None
+    else:
+        interval_res = Interval(max_value=max_value, min_value=min_value)
+        return interval_res
+
+
+def distance_number_to_interval(value: float, interval: Interval) -> float:
+    """
+    Calculate the distance between a number and an interval.
+
+    Args:
+        value: The number.
+        interval: The interval.
+
+    Returns:
+        The distance between the number and the interval.
+
+    Raises:
+        AssertionError: If the interval has missing values.
+
+    """
+    assert interval.max_value is not None and interval.min_value is not None
+    if value < interval.min_value:
+        return interval.min_value - value
+    elif value > interval.max_value:
+        return value - interval.max_value
+    else:
+        return 0
+
+
+def softmax(x: Sequence[float], temperature: float = 1.0) -> List[float]:
+    """Compute a softmax distribution over input values."""
+    if not x:
+        return []
+
+    # numerical stability
+    m = max(x)
+    scaled = [(v - m) * temperature for v in x]
+
+    exp_vals = [exp(v) for v in scaled]
+    s = sum(exp_vals)
+
+    return [v / s for v in exp_vals]