craceplot 0.1.0__py3-none-any.whl

craceplot/_utils/_base.py

@@ -0,0 +1,196 @@
+# craceplot._core._utils.py
+
+import re
+import copy
+import inspect
+import numpy as np
+from functools import wraps
+from typing import get_origin, get_args, Union, Literal, TypeVar, ParamSpec
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+dispatch_table_param = {}
+methods_table_param = {}
+def register_param(names):
+    if isinstance(names, str):
+        names = [names]
+
+    primary_name = names[0]
+
+    def decorator(func):
+        for name in names:
+            if name not in dispatch_table_param.keys():
+                dispatch_table_param[name] = func
+            if name not in methods_table_param.keys():
+                methods_table_param[name] = primary_name
+        return func
+    return decorator
+
+
+dispatch_table_exps = {}
+methods_table_exps = {}
+def register_exps(names):
+    if isinstance(names, str):
+        names = [names]
+
+    primary_name = names[0]
+
+    def decorator(func):
+        for name in names:
+            if name not in dispatch_table_exps.keys():
+                dispatch_table_exps[name] = func
+            if name not in methods_table_exps.keys():
+                methods_table_exps[name] = primary_name
+        return func
+    return decorator
+
+
+def short_type(t):
+    import builtins
+    if t in vars(builtins).values():  # builtin types keep as-is
+        return t
+
+    class NewName:
+        __name__ = t.__name__
+        __qualname__ = t.__name__
+
+    try:
+        del NewName.__module__
+    except Exception:
+        NewName.__module__ = None
+
+    return NewName
+
+
+def enforce_types(func):
+    sig = inspect.signature(func)
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        bound = sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+
+        for name, value in bound.arguments.items():
+            if value is None:
+                continue
+
+            expected = sig.parameters[name].annotation
+
+            if expected is inspect._empty:
+                continue
+
+            # Forward reference
+            if isinstance(expected, str):
+                if expected == "CraceResults":
+                    from crace.containers.crace_results import CraceResults
+                    expected = CraceResults
+                else:
+                    continue
+
+            check_type(value, expected, name)
+
+        return func(*args, **kwargs)
+
+    wrapper.__signature__ = sig
+    return wrapper
+
+
+def check_type(value, expected, name):
+    origin = get_origin(expected)
+    args = get_args(expected)
+
+    # ===== Union: try ALL branches =====
+    if origin is Union:
+        for t in args:
+            try:
+                check_type(value, t, name)
+                return  # any branch ok
+            except Exception:
+                pass
+        raise TypeError(
+            f"Argument/Option '{name}' does not match any allowed type in {args}, "
+            f"got {value!r}({type(value)})"
+        )
+
+    # ===== Literal =====
+    if origin is Literal:
+        if value not in args:
+            raise ValueError(
+                f"Argument/Option '{name}' must be one of {args}, got {value!r}"
+            )
+        return
+
+    # --------------------------------
+    # list / list[T]
+    # --------------------------------
+    if origin is list or expected is list:
+        if not isinstance(value, list):
+            raise TypeError(f"Argument/Option '{name}' must be list, got {type(value)}")
+
+        if len(args) == 0:
+            return
+
+        elem_type = args[0]
+
+        for v in value:
+            check_type(v, elem_type, name)
+
+        return
+
+    # tuple[T, ...]
+    if origin is tuple:
+        if not isinstance(value, tuple):
+            raise TypeError(f"Argument/Option '{name}' must be tuple")
+        elem_types = args
+        if len(elem_types) == 2 and elem_types[1] is Ellipsis:
+            for v in value:
+                check_type(v, elem_types[0], name)
+        else:
+            for v, t in zip(value, elem_types):
+                check_type(v, t, name)
+        return
+
+    # ===== NoneType =====
+    if expected is type(None):
+        if value is not None:
+            raise TypeError(f"Argument/Option '{name}' must be None")
+        return
+
+    # ===== normal class =====
+    if isinstance(expected, type):
+        if not isinstance(value, expected):
+            raise TypeError(
+                f"Argument/Option '{name}' expected {expected}, got {type(value)}"
+            )
+        return
+
+
+def safe_copy(obj):
+    try:
+        return copy.deepcopy(obj)
+    except Exception:
+        return obj
+
+
+def parse_range_list(s: str):
+    """
+    Parse '[start:stop]' or '[start:stop:step]' into list[int].
+    Python range semantics: stop is exclusive.
+    """
+    re_format = re.compile(
+        r'^\s*\[?\s*(-?\d+)\s*:\s*(-?\d+)(?:\s*:\s*(-?\d+(?:\.\d+)?))?\s*\]?\s*$')
+    m = re_format.match(s)
+    print(s, m)
+    if not m:
+        return None
+
+    start = int(m.group(1))
+    stop = int(m.group(2))
+    step = m.group(3)
+
+    if step is None:
+        return np.arange(start, stop+1).tolist()
+    else:
+        step = eval(step)
+        return np.arange(start, stop+step, step).tolist()

craceplot/_utils/_const.py

@@ -0,0 +1,8 @@
+bold = '\033[1m'
+underline = '\033[4m'
+reset = '\033[0m'
+
+WIDTH = 100
+
+DELTA = 1e-4
+EPSILON = 1e-10

craceplot/_utils/_crace.py

@@ -0,0 +1,42 @@
+import os
+import sys
+
+def _setup_crace(crace_main_custom_file=None):
+    if crace_main_custom_file is not None:
+        for name in list(sys.modules):
+            if name == "crace" or name.startswith("crace."):
+                del sys.modules[name]
+        crace_main_file = crace_main_custom_file
+    else:
+        crace_main_file = os.environ.get("CRACE_MAIN_FILE")
+
+    # case 1: if CRACE_MAIN_FILE exists
+    if crace_main_file and os.path.exists(crace_main_file):
+        # from .../crace/scripts/main.py → return .../crace
+        crace_home = os.path.dirname(os.path.dirname(os.path.dirname(crace_main_file)))
+
+        # insert crace home to path
+        if crace_home not in map(os.path.abspath, sys.path):
+            sys.path.insert(0, str(crace_home))
+
+    try:
+        import crace
+        return crace
+    except ImportError as exc:
+        if crace_main_file:
+            raise RuntimeError(
+                f"Failed to import crace from CRACE_MAIN_FILE directory:\n{crace_home}"
+            ) from exc
+        else:
+            raise RuntimeError(
+                "CRACE_MAIN_FILE is not set, and 'import crace' also failed.\n"
+                "Please set CRACE_MAIN_FILE to point to crace/scripts/main.py, \n"
+                "or provide the path to crace/scripts/main.py after --crace or -c in command line arguments."
+            ) from exc
+
+def get_crace(crace_main_file=None):
+    return _setup_crace(crace_main_file)
+
+def get_CraceResults():
+    from crace.containers.crace_results import CraceResults
+    return CraceResults

craceplot/_utils/_format.py

@@ -0,0 +1,191 @@
+import re
+import pandas as pd
+
+from craceplot._utils._const import WIDTH
+
+_ESCAPE_RE = re.compile(r'\\([ntrfvab\\])')
+_ESCAPE_MAP = {
+    "n": "\n",
+    "t": "\t",
+    "r": "\r",
+    "f": "\f",
+    "v": "\v",
+    "a": "\a",
+    "b": "\b",
+    "\\": "\\",
+}
+
+def _decode_escape(text: str):
+    return _ESCAPE_RE.sub(lambda m: _ESCAPE_MAP[m.group(1)], text)
+
+def _strip_ansi(s: str) -> str:
+    # CSI (colors, style, etc.)
+    s = re.sub(r'\x1b\[[0-9;]*m', '', s)
+    # OSC 8 hyperlinks: ESC ] 8 ;; ... ESC \
+    s = re.sub(r'\x1b]8;;.*?\x1b\\', '', s)
+    return s
+
+def _ansi_wrap(text: str, width: int, hanging: int, space: bool=False):
+    """
+    textwrap based on visible width (ANSI-aware)
+    preserve explicit newlines
+    hanging applies to wrapped lines inside each paragraph
+    """
+    out = []
+
+    paras = text.split("\n")
+
+    for i, para in enumerate(paras):
+        if para.strip() == "":
+            out.append("")
+            continue
+
+        out.extend(_ansi_wrap_one_para(para, width, hanging, space, i==0))
+
+    return out
+
+def _ansi_wrap_one_para(text: str, width: int, hanging: int, space: bool, init_line: bool):
+    base_indent = ""
+
+    if space:
+        text = text.replace(r"\t", "\t").expandtabs(2)
+        m = re.match(r"^ *", text)
+        base_indent = m.group(0)
+        text = text[len(base_indent):]
+
+    words = text.split()
+    lines = []
+    current = ""
+    first = True
+
+    available_width = width - len(base_indent) - hanging    # available width
+    hanging_indent = base_indent + " " * hanging
+
+
+    for w in words:
+
+        test = w if not current else current + " " + w
+
+        if len(_strip_ansi(test)) > available_width:
+            if current:
+                if first and init_line:
+                    lines.append(base_indent + current)
+                else:
+                    lines.append(hanging_indent + current)
+            current = w
+            first = False
+        else:
+            current = test 
+
+    if current:
+        if first and init_line:
+            lines.append(base_indent + current)
+        else:
+            lines.append(hanging_indent + current)
+
+    return lines
+
+def _make_ascii_box(text: str, width: int, hanging: int):
+    """replace xwarningbox to ascii format"""
+    # textwrap
+    lines = _ansi_wrap(text, width-2, hanging)
+    maxw = max(len(_strip_ansi(l)) for l in lines) if lines else 0
+
+    top = "  +" + "-" * (maxw + 2) + "+"
+    box = [top]
+    for l in lines:
+        pad = maxw - len(_strip_ansi(l))
+        box.append(f"  | {l}{' ' * pad} |")
+    box.append(top)
+
+    return "\n".join(box)
+
+def _make_ascii_list(text: str, width: int, hanging: int):
+    """
+    transform itemsize to ascii format
+    """
+    ITEM_RE = re.compile(r"\\item\[\]\s*(.*?)(?=\\item\[\]|$)", re.DOTALL)
+
+    items = ITEM_RE.findall(text)
+    if not items:
+        return ""
+
+    output = []
+    for item in items:
+        item = item.strip()
+
+        wrapped = _ansi_wrap(item, width-4, hanging)   # with prefix "- "
+        if wrapped:
+            # first line with prefix "- "
+            output.append(f"  - {wrapped[0]}")
+            # other lines
+            for w in wrapped[1:]:
+                output.append(f"    {w}")
+        else:
+            output.append("-")
+
+    return "\n".join(output)
+
+def format_string(text: str, width: int=WIDTH, hanging: int=0, space: bool=False):
+    """
+    - transform xwarningbox → ASCII frame
+    - transform itemize → ASCII list
+    - textwrap for other text
+
+    :param text: input string
+    :param width: max width of output string
+    :param hanging: hanging indent for wrapped lines
+    :param space: whether to preserve spaces and tabs at the beginning of each line
+    """
+    output = []
+    pos = 0
+
+    # search patterns: warningbox -> itemize
+    for match in re.finditer(
+        r"(\\begin{xwarningbox}.*?\\end{xwarningbox}|"
+        r"\\begin{itemize}.*?\\end{itemize})",
+        text,
+        flags=re.DOTALL,
+    ):
+        start, end = match.span()
+        before = text[pos:start]
+
+        # normal text in front
+        if before.strip():
+            output.append("\n".join(_ansi_wrap(before, width, hanging)))
+
+        block = match.group(1)
+
+        # xwarningbox
+        if block.startswith(r"\begin{xwarningbox}"):
+            content = re.search(r"\\begin{xwarningbox}\s*(.*?)\s*\\end{xwarningbox}", block, re.DOTALL).group(1)
+            output.append(_make_ascii_box(content.strip(), width, hanging))
+
+        # itemize
+        elif block.startswith(r"\begin{itemize}"):
+            content = re.search(r"\\begin{itemize}\s*(.*?)\s*\\end{itemize}", block, re.DOTALL).group(1)
+            output.append(_make_ascii_list(content.strip(), width, hanging))
+
+        pos = end
+
+    # normal text in the end
+    tail = text[pos:]
+    if tail.strip():
+        output.append("\n".join(_ansi_wrap(tail, width, hanging, space)))
+
+    return "\n".join(output)
+
+
+class ConditionalReturn:
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs if len(kwargs) != 0 else None
+
+    def __repr__(self):
+        if self.kwargs:
+            for k,v in self.kwargs.items():
+                if isinstance(v, pd.DataFrame) and 'title' in v.attrs and v.attrs['title']:
+                    print(f"{v.attrs['title']} \n{v}\n")
+                elif isinstance(v, str):
+                    print(f"{v}")
+                else: print(f'{k}: {v}')
+        return ""

craceplot/_vergit.py

@@ -0,0 +1,2 @@
+__version__ = "$Format:%d$"
+__full_version__ = "$Format:%H$"

craceplot/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = 'g120756444'