keecas 0.1.1__tar.gz

keecas-0.1.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: keecas
+Version: 0.1.1
+Summary: A set of tools for symbolic math computation done in a jupyter notebook, aimed specifically for Quarto. It is based mostly on sympy.
+Author: kompre
+Author-email: s.follador@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: flatten-dict (>=0.4.2,<0.5.0)
+Requires-Dist: ipython (>=8.26.0,<9.0.0)
+Requires-Dist: pint (>=0.24.3,<0.25.0)
+Requires-Dist: pipe (>=2.2,<3.0)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: regex (>=2024.7.24,<2025.0.0)
+Requires-Dist: ruamel-yaml (>=0.18.6,<0.19.0)
+Requires-Dist: sympy (>=1.13.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+

keecas-0.1.1/keecas/__init__.py

@@ -0,0 +1,52 @@
+# dataframe
+from .dataframe import Dataframe
+
+# display
+from .display import (
+    options,
+    show_eqn,
+    verifica,
+    dict_to_eq,
+    eq_to_dict,
+)
+
+# pipe_command
+from . import pipe_command as pc
+
+# initialize pint
+from .pint_sympy import unitregistry as u
+
+u.formatter.default_format = ".2f~P"
+
+# initialize sympy
+import sympy as sp
+
+from sympy import latex, Eq, Le, symbols, Basic, Dict, S, ImmutableDenseMatrix as Matrix
+
+## latex printing settings
+sp.init_printing(mul_symbol=options.default_mul_symbol, order="none")
+platex = lambda x: latex(x, mode="inline", mul_symbol=options.default_mul_symbol)
+
+## common sympy functions
+
+
+__all__ = [
+    "Dataframe",
+    "show_eqn",
+    "options",
+    "verifica",
+    "dict_to_eq",
+    "eq_to_dict",
+    "pc",
+    "u",
+    "sp",
+    "latex",
+    "Eq",
+    "Le",
+    "symbols",
+    "Basic",
+    "Dict",
+    "S",
+    "Matrix",
+    "platex",
+]

keecas-0.1.1/keecas/dataframe.py

@@ -0,0 +1,271 @@
+import copy
+
+from itertools import chain
+
+
+class Dataframe(dict):
+    def __init__(self, *args, filler=None, **kwargs):
+        super().__init__()
+        self._width = 0
+        self._filler = filler
+
+        if (
+            args
+            and isinstance(args[0], list)
+            and all(isinstance(item, dict) for item in args[0])
+        ):
+            self._init_from_list_of_dicts(args[0])
+        else:
+            self._update_initial(*args, **kwargs)
+
+    def _init_from_list_of_dicts(self, list_of_dicts):
+        if not list_of_dicts:
+            return
+
+        keys = list(
+            list_of_dicts[0].keys()
+        )  # the keys are determined by the first dict (order is important!)
+        for key in keys:
+            self[key] = [d.get(key, self._filler) for d in list_of_dicts]
+
+        self._width = len(list_of_dicts)
+
+    def _update_initial(self, *args, **kwargs):
+        if args:
+            if len(args) > 1:
+                raise TypeError(
+                    "update expected at most 1 arguments, got %d" % len(args)
+                )
+            other = dict(args[0])
+            other.update(kwargs)
+        else:
+            other = kwargs
+
+        for key, value in other.items():
+            if isinstance(value, list):
+                self[key] = value
+            else:
+                self[key] = [value]
+
+        self._width = max(len(value) for value in self.values()) if self else 0
+        self._validate_and_fill_data()
+
+    def _validate_and_fill_data(self):
+        if not self:
+            return
+
+        for key, value in self.items():
+            if len(value) < self._width:
+                self[key] = value + [self._filler] * (self._width - len(value))
+
+    def update(self, *args, **kwargs):
+        if args:
+            if len(args) > 1:
+                raise TypeError(
+                    "update expected at most 1 arguments, got %d" % len(args)
+                )
+            other = dict(args[0])
+            other.update(kwargs)
+        else:
+            other = kwargs
+
+        # Convert all values to lists if they aren't already
+        for key, value in other.items():
+            if not isinstance(value, list):
+                other[key] = [value]
+
+        # Find the maximum length of any value in both self and other
+        max_length = max(
+            [len(value) for value in self.values()]
+            + [len(value) for value in other.values()]
+            + [self._width]
+        )
+
+        # Update existing keys and add new ones
+        for key, value in other.items():
+            self[key] = value + [self._filler] * (max_length - len(value))
+
+        # Adjust existing keys that weren't in the update data
+        for key in self:
+            if key not in other:
+                if len(self[key]) < max_length:
+                    self[key] = self[key] + [self._filler] * (
+                        max_length - len(self[key])
+                    )
+                else:
+                    self[key] = self[key][:max_length]
+
+        # Update width
+        self._width = max_length
+
+    def append(self, other, strict=True):
+        if isinstance(other, Dataframe):
+            if strict:
+                other = {key: other[key] for key in self.keys() if key in other}
+
+            for key in self.keys():
+                self[key].append(
+                    other[key][0]
+                    if key in other and len(other[key]) > 0
+                    else self._filler
+                )
+        elif isinstance(other, dict):
+            if strict:
+                other = {key: other[key] for key in self.keys() if key in other}
+
+            for key in self.keys():
+                self[key].append(other[key] if key in other else self._filler)
+        else:
+            for key in self.keys():
+                self[key].append(other)
+
+        self._width += 1
+
+    def extend(self, other, strict=True):
+        if isinstance(other, Dataframe):
+            # filter keys
+            if strict:
+                other = Dataframe(
+                    {key: other[key] for key in self.keys() if key in other}
+                )
+                if not other:
+                    return
+
+            other_width = other.width
+
+            extra_keys = [k for k in other.keys() if k not in self.keys()]
+
+            for key in chain(self.keys(), extra_keys):
+                match (key in self, key in other):
+                    case (True, True):
+                        self[key].extend(
+                            other[key]
+                            + [self._filler] * (other_width - len(other[key]))
+                        )
+                    case (True, False):
+                        self[key].extend([self._filler] * other_width)
+                    case (False, True):
+                        self[key] = (
+                            [self._filler] * self._width
+                            + other[key]
+                            + [self._filler] * (other_width - len(other[key]))
+                        )
+
+            self._width += other_width
+        elif isinstance(other, dict):
+            # filter keys
+            if strict:
+                other = {key: other[key] for key in self.keys() if key in other}
+                if not other:
+                    return
+            self.extend(Dataframe(other), strict=strict)
+
+            # max_len = max(len(v) if isinstance(v, list) else 1 for v in other.values())
+
+            # for key in self.keys():
+            #     if key in other:
+            #         v = other[key]
+            #         if isinstance(v, list):
+            #             self[key].extend(v + [self._filler] * (max_len - len(v)))
+            #         else:
+            #             self[key].extend([v] * max_len)
+            #     else:
+            #         self[key].extend([self._filler] * max_len)
+
+            # self._width += max_len
+        elif isinstance(other, list):
+            for key in self.keys():
+                self[key].extend(other)
+
+            self._width += len(other)
+        else:
+            raise ValueError(
+                "Cannot extend Dataframe with this type. Use 'append' for single values."
+            )
+
+    def __add__(self, other):
+        # if not isinstance(other, Dataframe):
+        #     raise ValueError("Can only add Dataframe to Dataframe")
+        result = copy.deepcopy(Dataframe(self))
+        result.extend(other, strict=False)
+        return result
+
+    def __or__(self, other):
+        # if not isinstance(other, Dataframe):
+        #     raise ValueError("Can only perform '|' operation with Dataframe")
+        result = copy.deepcopy(Dataframe(self))
+        result.update(other)
+        return result
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def length(self):
+        return len(self)
+
+    @property
+    def shape(self):
+        return (self.length, self.width)
+
+    def __repr__(self):
+        return f"Dataframe({self.dict_repr()}, shape={self.shape})"
+
+    def dict_repr(self):
+        return super().__repr__()
+
+    def print_dict(self):
+        print(self.dict_repr())
+
+
+from typing import List, Union, Dict
+
+
+def create_dataframe(
+    keys: List[str],
+    width: int,
+    seed: Union[any, List, Dict, "Dataframe"] = None,
+    default_value: any = None,
+) -> Dataframe:
+
+    df = Dataframe()
+
+    if not isinstance(seed, (list, dict, Dataframe)):
+        # Single value seed (can be of any type)
+        for key in keys:
+            df[key] = [seed] * width
+
+    elif isinstance(seed, list):
+        # List seed (applies to all rows)
+        seed_list = seed[:width] + [default_value] * (width - len(seed))
+        for key in keys:
+            df[key] = seed_list.copy()
+
+    elif isinstance(seed, Dataframe):
+        for key in keys:
+            if key in seed:
+                df[key] = seed[key][:width] + [default_value] * (width - len(seed[key]))
+            else:
+                df[key] = [default_value] * width
+
+    elif isinstance(seed, dict):
+        for key in keys:
+            if key in seed:
+                if isinstance(seed[key], list):
+                    # List value for this row
+                    df[key] = seed[key][:width] + [default_value] * (
+                        width - len(seed[key])
+                    )
+                else:
+                    # Single value for this row
+                    df[key] = [seed[key]] * width
+            else:
+                df[key] = [default_value] * width
+
+    # Fill any missing rows with default_value
+    for key in keys:
+        if key not in df:
+            df[key] = [default_value] * width
+
+    return df

keecas-0.1.1/keecas/display.py

@@ -0,0 +1,435 @@
+# %%
+from warnings import warn
+from sympy import (
+    latex,
+    Eq,
+    Le,
+    symbols,
+    Basic,
+    FunctionClass,
+    Dict,
+    S,
+)
+from IPython.display import Markdown, display
+import re
+
+from typing import Union, List, Dict
+
+from .dataframe import *
+
+# DEFINITION OF DEFAULT VALUES
+
+# default values for labels
+from dataclasses import dataclass
+
+
+@dataclass
+class options:
+    EQ_PREFIX: str = "eq-"
+    EQ_SUFFIX: str = ""
+    VERTICAL_SKIP: str = "8pt"
+    PRINT_LABEL: bool = False
+    DEBUG = False
+    katex = False
+    default_mul_symbol = r"\,"
+    default_environment = "align"
+    default_label_command = r"\label"
+
+
+from itertools import chain, zip_longest
+
+
+# determina esito verifica
+def verifica(lhs, rhs, test=Le) -> Markdown:
+    """Determines if the left-hand side (lhs) is less than or equal to
+    the right-hand side (rhs) based on the provided test function.
+
+    Args:
+        lhs (sympy.Expr): The left-hand side expression.
+        rhs (sympy.Expr): The right-hand side expression.
+        test (sympy.GreaterThan, sympy.LessThan, sympy.GreaterThanEqual, sympy.LessThanEqual, optional):
+            The test function to apply. Defaults to Le (less than or equal to).
+
+    Returns:
+        Markdown: A Markdown object containing the formatted string indicating the verification result (green for success, red for failure).
+    """
+    match test.__name__:
+        case "LessThan":
+            symbol_if_true = r"\le"
+            symbol_if_false = r">"
+        case "StrictLessThan":
+            symbol_if_true = r"<"
+            symbol_if_false = r"\ge"
+        case "GreaterThan":
+            symbol_if_true = r"\ge"
+            symbol_if_false = r"<"
+        case "StrictGreaterThan":
+            symbol_if_true = r">"
+            symbol_if_false = r"\le"
+
+    if test(lhs, rhs):
+        return Markdown(
+            rf"\textcolor{{green}}{{\left[{symbol_if_true}{rhs}\quad \textbf{{VERIFICATO}}\right]}}"
+        )
+    else:
+        return Markdown(
+            rf"\textcolor{{red}}{{\left[{symbol_if_false}{rhs}\quad \textbf{{NON VERIFICATO}}\right]}}"
+        )
+
+
+def show_eqn(
+    eqns: dict | list[dict] | Dataframe,
+    environment: str = None,
+    sep: str | list[str] = "&",
+    label: str | dict = None,
+    label_command: str = None,
+    col_wrap: list[None | tuple] = None,
+    float_format: str = None,
+    debug: bool = None,
+    **kwargs,
+) -> Markdown:
+    """
+    Generates a LaTeX equation or equation array based on the provided equations.
+
+    Args:
+        eqns (dict | list[dict] | Dataframe): The equations to be displayed. It can be a dictionary, a list of dictionaries, or a Dataframe object.
+        environment (str, optional): The LaTeX environment to use for displaying the equations. Defaults to options.default_environment.
+        sep (str | list[str], optional): The separator to use between the key and value in each equation. It can be a string or a list of strings. Defaults to "&" or "" for specific environments (e.g. equation, gather).
+        label (str | dict, optional): The label to attach to the equation. It can be a string or a dictionary. Defaults to None.
+        label_command (str, optional): The LaTeX command to use for attaching the label. Defaults to options.default_label_command.
+        col_wrap (list[None | tuple], optional): The column wrapping specification for the Dataframe. Defaults to [None, ('=', '')].
+        float_format (str, optional): The float format specification for the Dataframe. Defaults to None.
+        debug (bool, optional): Whether to enable debug mode. Defaults to options.DEBUG.
+        **kwargs: Additional keyword arguments to be passed to the `myprint_latex` function.
+
+    Returns:
+        Markdown: The LaTeX equation or equation array displayed as a Markdown object.
+
+    Notes:
+        - If `debug` is True, the generated LaTeX code will be printed.
+        - If `environment` is not provided, the default environment specified in `options.default_environment` will be used.
+        - If `col_wrap` is not provided, the default column wrapping specification will be used.
+        - If `float_format` is not provided, the default float format specification will be used.
+        - If `label` is not provided, a label will not be attached to the equation.
+        - If `label_command` is not provided, the default label command specified in `options.default_label_command` will be used.
+        - The `eqns` argument can be a dictionary, a list of dictionaries, or a Dataframe object.
+        - The `sep` argument can be a string or a list of strings.
+        - The `label` argument can be a string or a dictionary.
+        - The `label_command` argument can be a string.
+        - The `col_wrap` argument can be a list of None or tuples.
+        - The `float_format` argument can be a string.
+        - The `debug` argument can be a boolean.
+        - The `**kwargs` argument can be any additional keyword arguments to be passed to the `myprint_latex` function.
+
+    """
+
+    # set defualt values
+    if not debug:
+        debug = options.DEBUG
+
+    if not "mul_symbol" in kwargs:
+        kwargs["mul_symbol"] = options.default_mul_symbol
+
+    if not environment:
+        environment = options.default_environment
+
+    if not col_wrap:
+        col_wrap = [
+            None,
+            ("=", ""),
+        ]  # no wrapping for the key element (first columns), then '=' sign for the second column
+
+    # warning message in case of too many labels provided
+    single_label_env = ["equation", "cases", "split"]
+    if environment.replace("*", "") in single_label_env and isinstance(label, dict):
+        warn(
+            f"ATTENTION! label is a dict, while the {environment} does not support multiple labels"
+        )
+
+    # handle edge case for 'equation' and 'gather' environment
+    if environment.replace("*", "") in ["equation", "gather"]:
+        sep = ""  # no separator in environment
+
+    # convert sep to a list: str-> list[str]
+    if not isinstance(sep, list):
+        sep = [sep]
+
+    # convert eqns to a Dataframe
+    if not isinstance(eqns, Dataframe):
+        if isinstance(eqns, list):
+            eqns = Dataframe(eqns)
+        else:
+            eqns = Dataframe([eqns])
+
+    # adjust sep to the size of the list of eqns(e.g. 'key & val0 & val1' ); assume last value of sep as filler
+    sep += [sep[-1]] * (eqns.width - len(sep))
+
+    # extract keys from first dict
+    keys = eqns.keys()
+    # determine the number of columns (keys & value0 & value1 ...)
+    num_cols = eqns.width + 1
+
+    # generate the matrix (list[list]]) of keys, many values (first element is the key)
+    matrix = {k: [k] + [vv for vv in v] for k, v in eqns.items()}
+    # print(f'{matrix=}')
+
+    # create float_format (dict)
+    if isinstance(float_format, tuple):
+        float_format = create_dataframe(seed=float_format[0], default_value=float_format[1], keys=keys, width=num_cols)
+    else:
+        float_format = create_dataframe(seed=float_format, keys=keys, width=num_cols)
+    # print(f'{float_format=}')
+
+    ### col_wrap
+    # adjust size of the col_wrap; assume None as default (for compatibility with earlier versions)
+    col_wrap = create_dataframe(seed=col_wrap, keys=keys, width=num_cols)
+
+    for k, v in col_wrap.items():
+        # clean the none value in wrapper with tuple
+        col_wrap[k] = [cw if cw is not None else ("", "") for cw in v]
+        # substitute single value with tuple, assuming last item is ''
+        col_wrap[k] = [cw if isinstance(cw, tuple) else (cw, "") for cw in col_wrap[k]]
+
+    # generate label dict if none is passed
+    if not label:
+        label = {k: None for k in keys}
+
+    # define label command
+    if not label_command:
+        label_command = options.default_label_command
+
+    def attach_label(key):
+        """
+        Attaches a label to a given key.
+
+        Parameters:
+            key (str): The key to attach the label to.
+
+        Returns:
+            str: The label attached to the key. If the label is empty or the katex engine is being used for rendering (i.e. in a Jupyter notebook), an empty string is returned.
+
+        Notes:
+            - The label is constructed using the `options.EQ_PREFIX`, the value of `label[key]`, and `options.EQ_SUFFIX`.
+            - If `options.PRINT_LABEL` is True, the key and label are printed.
+            - The label is wrapped in a LaTeX command specified by `label_command` if it is not empty and the katex engine is not being used for rendering.
+        """
+        
+        if isinstance(label, dict):
+            text_label = (
+                rf"{options.EQ_PREFIX}{label[key]}{options.EQ_SUFFIX}" 
+                if label.get(key)
+                else ""
+            )
+            if options.PRINT_LABEL:
+                print(f"{key}: {text_label}") if text_label else None
+
+            return (
+                rf" {label_command}{{{text_label}}} "
+                if label.get(key)
+                and not options.katex  # don't add the label if there is no label to add, and if katex engine is used for rendering (i.e. jupyter notebook)
+                else ""
+            )
+        
+        if isinstance(label, str) and not key:
+            
+            text_label = rf"{options.EQ_PREFIX}{label}{options.EQ_SUFFIX}"
+            
+            if options.PRINT_LABEL:
+                print(f"label: {text_label}" if text_label else None)
+
+            return (
+                rf" {label_command}{{{text_label}}} "
+                if not options.katex  # don't add the label if there is no label to add, and if katex engine is used for rendering (i.e. jupyter notebook)
+                else ""
+            )
+            
+        return ""
+
+        
+
+    # check if environment is a special (starred "cases*" and "split*" are not valid latex environment, but they need to pass the "*" operator to the "equation" outer environment)
+    if environment.replace("*", "") in ["cases", "split"]:
+
+        # determine if outer env is starred
+        env = "align*" if "*" in environment else "align"
+
+        # clear the cases|split environment from the star
+        environment = "aligned"
+
+        # wrap inner cases|split in outer "align"
+        wrap = (
+            f"\\begin{{{env}}}{attach_label(None)}\n",  # for an equation environment, only one label is allowed
+            f"\t\\left\\{{\\begin{{{environment}}}",
+            f"\t\n\\end{{{environment}}}\\right.",
+            f"\n\\end{{{env}}}",
+        )
+
+    else:
+        # do nothing
+        wrap = (
+            "",
+            f"\\begin{{{environment}}}{attach_label(list(keys)[0]) if environment.replace('*', '') in single_label_env else ''}",
+            f"\n\\end{{{environment}}}",
+            "",
+        )
+
+    # definition of the main template
+    template = f"{wrap[0]}{wrap[1]}\n___body___{wrap[2]}{wrap[3]}"
+
+    # generate the rows
+    body_lines = {}
+    for key, list_values in matrix.items():
+        body_lines[key] = " ".join(
+            [
+                format_decimal_numbers(
+                    f'{ f"{cw[0]}{myprint_latex(v, **kwargs)}{cw[-1]}" if v is not None else " " } {s}',
+                    ff,
+                )
+                for v, s, cw, ff in zip_longest(
+                    list_values,
+                    sep,
+                    col_wrap[key],
+                    float_format[key],
+                    fillvalue="",
+                )
+            ]
+        ) + attach_label(key)
+
+    # how to join the lines of the body
+    join_token = "" if "equation" in environment else " \\\\\n "
+
+    # generate the body
+    body = join_token.join(body_lines.values())
+
+    # clean the body
+    body = replace_all(body, replacement)
+
+    template = template.replace("___body___", body)
+
+    if debug:
+        print(template)
+
+    return Markdown(template)
+
+
+def myprint_latex(expr: Basic | str | Markdown, **kwargs) -> str:
+    """Converts a mathematical expression to a LaTeX string.
+
+    This function handles different input types and allows for customization of the output format.
+
+    Args:
+        expr (Basic | str | Markdown): The mathematical expression to convert.
+            * Basic (SymPy): A SymPy expression object.
+            * str: A string representation of a mathematical expression.
+            * Markdown: A Markdown object that likely contains LaTeX code (data attribute is extracted).
+        **kwargs: Additional keyword arguments passed to the SymPy `latex` function for formatting the output.
+
+    Returns:
+        str: The LaTeX string representation of the mathematical expression.
+    """
+    if isinstance(expr, Markdown):
+        return expr.data
+
+    return latex(expr, **kwargs)
+
+
+import re
+
+
+def wrap_floats(text, wrapper=("", "")):
+    # Define a regular expression pattern to match decimal numbers
+    float_pattern = re.compile(r"-?\d+\.\d+")
+
+    # Define a function to use as replacement
+    def wrap_match(match):
+        return f"{wrapper[0]}{match.group(0)}{wrapper[1]}"
+
+    # Use re.sub to replace all matches with the wrapped version
+    wrapped_text = float_pattern.sub(wrap_match, text)
+
+    return wrapped_text
+
+
+def format_decimal_numbers(text, format_string="{:.2f}"):
+    """
+    Finds all decimal numbers in a string, applies a specified format,
+    and substitutes them back into the string.
+
+    Args:
+        text: The string to search for decimal numbers.
+        format_string: The format string to apply to the decimal numbers.
+
+    Returns:
+        The formatted string.
+    """
+    if text is None or format_string is None:
+        return text
+
+    def format_match(match):
+        value = float(match.group())
+        return format_string.format(value)
+
+    return re.sub(r"-?\d+\.\d+", format_match, text)
+
+
+def dict_to_eq(result: dict):
+    eq = [Eq(k, v) for k, v in result.items()]
+    return eq if len(eq) > 1 else eq[0]
+
+
+def eq_to_dict(result: Eq | list | tuple):
+    if hasattr(result, "__iter__"):
+        return {x.lhs: x.rhs for x in result}
+    else:
+        return {result.lhs: result.rhs}
+
+
+import regex
+
+# replacements for the regex function
+replacement = {
+    r"\\frac": r"\\dfrac",  # fisrt replace all frac with dfrac
+    r"\^\{((?:[^{}]|(?:\{(?1)\}))*)}": lambda m: regex.sub(
+        "dfrac", "frac", m.group(0)
+    ),  # then replace all dfrac inside ^{} with frac (small exponent)
+    r"\b1 \\cdot": r"",
+    r"\\\\": rf"\\\\[{options.VERTICAL_SKIP}]",
+    r"\bfor\b": "per",
+    r"\botherwise\b": "altrimenti",
+    r"\\,": r"{\,}",
+}
+
+
+# %% replace all the key, value pair
+def replace_all(body, reps=replacement):
+    for pattern, repl in reps.items():
+        body = regex.sub(pattern, repl, body)
+    return body
+
+
+def latex_inline_dict(var, mapping: dict, **kwargs):
+    if not "mul_symbol" in kwargs:
+        kwargs["mul_symbol"] = r"\,"
+    match (mode := kwargs.get("mode")):
+        case "plain" | None:
+            wrap = ("", "")
+        case "inline":
+            wrap = ("$", "$")
+        case _:
+            wrap = (rf"\begin{{{mode}}}", rf"\end{{{mode}}}")
+
+    kwargs["mode"] = "plain"
+
+    _latex = lambda x: replace_all(latex(x, **kwargs))
+    return f"{wrap[0]}{_latex(var)} = {_latex(mapping[var])}{wrap[1]}"
+
+
+if __name__ == "__main__":
+    x, y = symbols("x y")
+    show_eqn(
+        {
+            x: 1,
+        },
+        label={x: "banana"},
+        debug=True,
+    )

keecas-0.1.1/keecas/pint_sympy.py

@@ -0,0 +1,95 @@
+import pint
+import sympy.physics.units as sympy_units
+from sympy.physics.units.util import convert_to
+
+from sympy import nsimplify, sympify
+
+unitregistry = pint.UnitRegistry()
+unitregistry.formatter.default_format = ".2f~P"
+
+def pint_to_sympy(quantity: unitregistry.Quantity):
+    """convert pint quantity to sympy quantity
+
+    Args:
+        quantity (UnitRegistry.Quantity): a quantity defined with the pint module
+
+    """
+    # divide and extract the magnitude from the units: it will generate a two elements tuple, where the first item will be the magnitude and the second ona a tuple of tuples; each nested tuple is composed by two elements, the unit proper and the exponent to which is elevated; the tuples are supposed to be multiplied together.
+
+    # quantity is multiplied by 1 so that it is converted to pint.Quantity if pint.Unit is passed instead
+    magnitude, units = (1 * quantity).to_tuple()
+
+    # for each unit (i.e. tuple), check if it exist in the sympy.physics.units module
+    for u in units:
+        fullname = u[0]
+        shortname = f"{pint.Unit(fullname):~}"
+        exponent = sympify(u[1])
+
+        # add a new unit if it doesn't exist
+        if not hasattr(sympy_units, fullname):
+            if [True for x in unitregistry.parse_unit_name(fullname) if not x[0] == ""]:
+                is_prefixed = True
+            else:
+                is_prefixed = False
+
+            setattr(
+                sympy_units,
+                fullname,
+                sympy_units.Quantity(
+                    fullname, abbrev=shortname, is_prefixed=is_prefixed
+                ),
+            )  # create thwith full namee new sympy unit
+            # create the alias with the shortname
+            setattr(sympy_units, shortname, getattr(sympy_units, fullname))
+
+            # set the global scale factor relative to base units (base units are assumed to be in sympy)
+            # _magnitude, _units = (1 * pint.Unit(fullname)).to_base_units().to_tuple()
+            # _reference = sympify(1)
+            # for _u in _units:
+            #     _reference *= getattr(sympy_units, _u[0])**nsimplify(_u[1])
+
+            # getattr(sympy_units, fullname).set_global_relative_scale_factor(_magnitude, _reference)
+
+        # multiply magnitude for the sympy units (create a sympy.core.Mul object)
+        magnitude *= (
+            getattr(sympy_units, fullname) ** (exponent)
+            if exponent != 1
+            else getattr(sympy_units, fullname)
+        )
+
+    return sympify(magnitude)
+
+
+# UnitRegistry = pint.UnitRegistry()
+# UnitRegistry.default_format = '.2f~P'
+# Q = UnitRegistry.Quantity
+# Q._sympy_ = lambda s: sympify(f'{s.m}*{s.u}')
+
+pint.Quantity._sympy_ = lambda x: pint_to_sympy(x)
+pint.Unit._sympy_ = lambda x: pint_to_sympy(1 * x)
+
+
+if __name__ == "__main__":
+    u = unitregistry
+
+    F = 5000 * u.daN  # this unit is not present in sympy.core.physics
+    A = 2 * u.m
+    B = 300 * u.cm
+
+    # pint unit get converted to sympy units
+    print(sympify(F))
+    print(sympify(A))
+    print(sympify(B))
+
+    # sympy will not automatically simplify different units
+    print(sympify(F / (A * B)))  # this is a pressure
+
+    # you need to use convert to
+
+    print(convert_to(sympify(F), u.kN))
+
+    print(convert_to(sympify(F / (A * B)), u.MPa))
+
+    print(convert_to(sympify(F / (A * B)), u.kPa))
+
+    print(f"{F:.4f~P}")

keecas-0.1.1/keecas/pipe_command.py

@@ -0,0 +1,196 @@
+# %% pipe command
+from pipe import Pipe
+from sympy.parsing.sympy_parser import parse_expr as sympy_parse_expr
+from sympy import Basic, sympify, S, Mul, MatrixBase, UnevaluatedExpr
+from sympy.core.function import UndefinedFunction
+from sympy.physics.units.util import convert_to as sympy_convert_to
+from sympy.physics.units.util import quantity_simplify as sympy_quantity_simplify
+from sympy import topological_sort, default_sort_key
+from itertools import permutations
+from inspect import currentframe
+from keecas.display import wrap_floats
+
+
+def order_subs(subs: dict) -> list[tuple]:
+    """Reorders the substitutions using topological order, ensuring that
+    the order of elements passed to the subs function is exhaustive.
+
+    Args:
+        subs (dict): Dictionary of substitutions to perform (VERTICES).
+
+    Returns:
+        list: Ordered list of substitutions.
+    """
+
+    # Generate edges between each vertex
+    edges = [
+        (i, j) for i, j in permutations(subs.items(), 2) if sympify(i[1]).has(j[0])
+    ]
+
+    # Reorder the dict with topological_sort
+    return topological_sort((subs.items(), edges), default_sort_key)
+
+
+@Pipe
+def subs(
+    expression: Basic,
+    substitution: dict,
+    sorted=True,
+    # simplify_quantity=True, **kwargs
+) -> Basic:
+
+    # filter out None expressions from the expression
+    if expression is None:
+        return
+
+    # filter out non Basic expressions from the substitution dict
+    substitution = {
+        lhs: rhs
+        for lhs, rhs in substitution.items()
+        if isinstance(lhs, Basic | UndefinedFunction | str) and rhs is not None
+    }
+
+    if sorted:
+        substitution = order_subs(substitution)
+
+    expression = S(expression).subs(substitution)
+
+    # if simplify_quantity:
+    #     expression = expression | quantity_simplify(**kwargs)
+
+    return expression
+
+
+@Pipe
+def N(expression: Basic, precision: int = 15) -> Basic:
+    return expression.evalf(precision)
+
+
+@Pipe
+def convert_to(expression: Basic, units=1) -> Basic:
+    return sympy_convert_to(expression, target_units=units)
+
+
+@Pipe
+def doit(expression: Basic) -> Basic:
+    return expression.doit()
+
+
+from sympy.parsing.sympy_parser import T
+
+
+@Pipe
+def parse_expr(
+    expression: Basic, local_dict: dict = None, evaluate=False, **kwargs
+) -> Basic:
+    """
+    Parses a mathematical expression into a SymPy expression object.
+
+    Parameters:
+        expression (Basic): The mathematical expression to parse.
+        local_dict (dict, optional): A dictionary of local variables to use during parsing. If None is passed, then the current frame's local variables will be used.
+        evaluate (bool, optional): Whether to evaluate the expression during parsing. Defaults to False.
+        **kwargs: Additional keyword arguments to pass to the SymPy parser.
+
+    Returns:
+        Basic: The parsed SymPy expression object.
+    """
+    
+    if not local_dict:
+        local_dict = currentframe().f_back.f_back.f_back.f_locals
+
+    if "transformations" not in kwargs:
+        kwargs["transformations"] = T[:11]
+
+    parsed_expr = sympy_parse_expr(
+        expression, evaluate=evaluate, local_dict=local_dict, **kwargs
+    )
+    return parsed_expr
+
+
+@Pipe
+def quantity_simplify(
+    expression: Basic, across_dimensions=True, unit_system="SI", **kwargs
+) -> Basic:
+    """
+    Simplifies a given expression by applying quantity simplification.
+
+    Parameters:
+        expression (Basic): The expression to simplify.
+        across_dimensions (bool): Whether to simplify across dimensions. Defaults to True.
+        unit_system (str): The unit system to use for simplification. Defaults to "SI".
+        **kwargs: Additional keyword arguments to pass to the underlying sympy_quantity_simplify function.
+
+    Returns:
+        Basic: The simplified expression.
+    """
+    
+    return sympy_quantity_simplify(
+        expression, across_dimensions=across_dimensions, unit_system=unit_system
+    )
+
+
+@Pipe
+def as_two_terms(
+    expression: Basic,
+    as_mul=False,
+) -> Basic:
+    """
+    This function takes in a `Basic` expression and an optional boolean flag `as_mul`. 
+    It checks if the expression is an instance of `Mul`. If it is, it calls the `as_two_terms()` method on the expression. 
+    If the expression is not an instance of `Mul`, it checks if it is an instance of `MatrixBase`. 
+    If it is, it creates a set of units by iterating over the values of the matrix and getting the coefficients dictionary of each element. 
+    If the set of units has a length of 1, it assigns the only unit to `u`, divides the matrix by `u`, and assigns the result to `att`. 
+    If the set of units has a length greater than 1, it returns the original expression. 
+    If the expression is neither a `Mul` nor a `MatrixBase`, it returns the original expression. 
+    Finally, it returns `att` if `as_mul` is `False`, otherwise it returns `att` combined with `as_Mul`.
+    """
+    if isinstance(expression, Mul):
+        att = expression.as_two_terms()
+    elif isinstance(expression, MatrixBase):
+        units = {u for e in expression.values() for u in e.as_coefficients_dict()}
+        if len(units) == 1:
+            u = units.pop()
+            att = (expression / u, u)
+        else:
+            return expression
+    else:
+        return expression
+
+    return att | as_Mul if as_mul else att
+
+
+@Pipe
+def as_Mul(expression: tuple[Basic]) -> Basic:
+    """
+    Multiplies two expressions together and returns the result as an unevaluated expression. (Ideally to nicely separate the magnitude from the units)
+
+    Parameters:
+        expression (tuple[Basic]): A tuple containing two Basic expressions to be multiplied together.
+
+    Returns:
+        Basic: The result of multiplying the two expressions together as an unevaluated expression.
+    """
+    
+    return UnevaluatedExpr(expression[0]) * UnevaluatedExpr(expression[1])
+
+
+# print(currentframe().f_back.f_locals)
+# %% debug
+
+if __name__ == "__main__":
+    import sympy as sp
+
+    x, y = sp.symbols("x y")
+
+    _d = {
+        x: 3,
+        y: x * 4,
+    }
+    print((None) | subs(_d))
+
+    e = sp.symbols("e", cls=sp.Function)
+    _e = {e: "Lambda(j, j+1)" | parse_expr}
+    print("e(x)" | parse_expr | subs(_e))
+
+# %%

keecas-0.1.1/keecas/utils.py

@@ -0,0 +1,96 @@
+# %% inserimento immagini in documento come link markdown
+import os
+from pathlib import Path
+from IPython.display import Markdown
+
+# %% flatten dict across yaml
+import flatten_dict as fd
+from ruamel.yaml import YAML
+
+yaml = YAML()
+yaml.preserve_quotes = True
+
+
+def load_data(main: str, updated_value: str) -> dict:
+    # Check if main file exists
+    if not os.path.exists(main):
+        # Create an empty file and return an empty dict
+        with open(main, "w") as f:
+            pass
+
+    # caricamento dati esistenti (generati automaticamente)
+    with open(main, "r") as m:
+        try:
+            _main = fd.flatten(yaml.load(m))
+        except ValueError:
+            _main = {}
+
+    # caricamento dei metadata (inseriti manualmente)
+    with open(updated_value, "r") as m:
+        _updated_value = fd.flatten(yaml.load(m))
+
+    return fd.unflatten(_main | _updated_value)
+
+
+# %% SYMPY
+def escape_name(symbol_name, dict_of_subs={}):
+    name = str(symbol_name)
+    for old, new in dict_of_subs.items():
+        name = name.replace(old, new)
+    return name
+
+
+def escape_var(names, dict_of_subs=None, **args):
+    """estensione di sympy:var() con l'introduzione di una lista di sostituzioni per escapare i nomi dei simboli
+
+    Args:
+        names (_type_): _description_
+        dict_of_subs (_type_, optional): _description_. Defaults to None.
+    """
+
+    def traverse(symbols, frame):
+        """Recursively inject symbols to the global namespace."""
+        for symbol in symbols:
+            if isinstance(symbol, Basic):
+                frame.f_globals[escape_name(symbol.name, dict_of_subs)] = symbol
+            elif isinstance(symbol, FunctionClass):
+                frame.f_globals[escape_name(symbol.__name__, dict_of_subs)] = symbol
+            else:
+                traverse(symbol, frame)
+
+    from inspect import currentframe
+
+    frame = currentframe().f_back
+
+    try:
+        if isinstance(names, str):
+            syms = symbols(names, **args)
+        else:
+            syms = names
+
+        if syms is not None:
+            if isinstance(syms, Basic):
+                frame.f_globals[escape_name(syms.name, dict_of_subs)] = syms
+            elif isinstance(syms, FunctionClass):
+                frame.f_globals[escape_name(syms.__name__, dict_of_subs)] = syms
+            else:
+                traverse(syms, frame)
+    finally:
+        del frame  # break cyclic dependencies as stated in inspect docs
+
+    return syms
+
+
+def insert_images(source_path, dest_path=".", fig_opt=""):
+    images = []
+
+    # filtra lista di immagini -> path object
+    for root, _, files in os.walk(source_path):
+        for f in files:
+            if f.lower().endswith((".jpg", ".jpeg", ".png")):
+                image = Path(root) / f
+                display(
+                    Markdown(
+                        f"![{image.stem}](<{image.relative_to(dest_path)}>){{{fig_opt}}}"
+                    )
+                )

keecas-0.1.1/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "keecas"
+version = "0.1.1"
+description = "A set of tools for symbolic math computation done in a jupyter notebook, aimed specifically for Quarto. It is based mostly on sympy."
+authors = ["kompre <s.follador@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+pint = "^0.24.3"
+pipe = "^2.2"
+sympy = "^1.13.1"
+regex = "^2024.7.24"
+ipython = "^8.26.0"
+pyyaml = "^6.0.1"
+flatten-dict = "^0.4.2"
+ruamel-yaml = "^0.18.6"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.2"
+ipykernel = "^6.29.5"