Merge pull request #13 from PascalGitz/pascals_playground

Pascals playground

Author: PascalGitz

engicalc.egg-info/PKG-INFO

@@ -12,7 +12,6 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Requires-Dist: sympy
-Requires-Dist: IPython
 
 # EngiCalc
 
@@ -31,7 +30,4 @@ Once the calculations are complete, they can be output as Word files using Quart
 
 ## Installation
 
-To install EngiCalc, use pip:
-
-```bash
-pip install engicalc
+Install from this Repo

engicalc.egg-info/SOURCES.txt

@@ -3,7 +3,9 @@ setup.py
 engicalc/__init__.py
 engicalc/concrete.py
 engicalc/main.py
+engicalc/materials.py
 engicalc/output.py
+engicalc/units.py
 engicalc.egg-info/PKG-INFO
 engicalc.egg-info/SOURCES.txt
 engicalc.egg-info/dependency_links.txt

engicalc.egg-info/requires.txt

@@ -1,3 +1,2 @@
 numpy
 sympy
-IPython

engicalc/__init__.py

@@ -1,4 +1,5 @@
+from engicalc.output import *
+
 import engicalc.concrete
-from engicalc.output import put_out, dict_to_markdown_table
-from engicalc.materials import Beton
+import engicalc.materials
 import engicalc.units

engicalc/output.py

@@ -1,24 +1,29 @@
 from IPython.display import display, Markdown, Latex
 import io
+import re
 from contextlib import redirect_stdout
-from sympy import Symbol, latex
+from sympy import Symbol, latex, Matrix
 import numpy as np
+from tabulate import tabulate
 
+# Define special characters and symbols
+special_characters = {
+    "diam": r"\oslash",
+    "apos": r"'",
+    "sum": r"\sum",
+    "comma": r",",
+}
 
-def put_out(offset: int = 0, precision: int = 2, rows: int = 3, horizontal: bool = True) -> None:
+def parse_cell_variables(offset: int = 0) -> dict:
     """
-    Renders the variables and their values as LaTeX equations in a Jupyter notebook.
+    Parses the cell history to extract variable names and their corresponding values.
 
     Args:
         offset (int): The number of previous cells to include for variable extraction. Defaults to 0.
-        precision (int): The precision for numerical values. Defaults to 2.
-        rows (int): Maximum number of equations per row in horizontal display. Defaults to 3.
-        horizontal (bool): Whether to display equations horizontally or vertically. Defaults to True.
 
     Returns:
-        None
+        dict: A dictionary with variable names as keys and their corresponding values from the user namespace.
     """
-    
     ipy = get_ipython()
     out = io.StringIO()
 
@@ -34,100 +39,141 @@ def put_out(offset: int = 0, precision: int = 2, rows: int = 3, horizontal: bool
     user_ns = ipy.user_ns
     variables = {name: user_ns[name] for name in variable_names if name in user_ns}
 
-
-    def format_value(value):
-        """Formats the value based on its type."""
-        if isinstance(value, (int, float)):
-            return round(value, precision)
-        elif isinstance(value, np.ndarray):
-            return np.array2string(np.round(value, precision), separator=",")
-        elif hasattr(value, "magnitude"):
-            magnitude = np.round(value.magnitude, precision)
-            if isinstance(magnitude, np.ndarray):
-                magnitude_str = np.array2string(magnitude, separator=",")
-                return f"{magnitude_str} \\ {latex(Symbol(str(value.units)))}"
-            else:
-                return f"{magnitude} \\ {latex(Symbol(str(value.units)))}"
-        else:
-            return value
+    return variables
 
 
-    # Format the variables and their values
-    formatted_vars = {name: format_value(value) for name, value in variables.items()}
 
-    if horizontal:
-        # Horizontal display with aligned '=' signs
-        var_list = list(formatted_vars.items())
+def format_name(name: str, symbols: dict = special_characters) -> str:
+    """Formats the input string with specific LaTeX replacements, handles underscores, and converts 'txt_' prefix to plain text."""
+    
+    # Regex to find words, underscores, and numbers separately
+    name_parts = re.findall(r'[a-zA-Z]+|_|\d+', name)
+    
+    result_parts = []
+    i = 0
 
-        # check if there are less variables than rows. This results in clean aligning of the equations
-        if len(var_list)<rows:
-            rows = len(var_list)
+    while i < len(name_parts):
+        part = name_parts[i]
 
-        markdown_str = "$$\n\\begin{aligned}\n"
-        # Iterate through the variables
-        for i in range(0, len(var_list), rows):
-                row = var_list[i : i + rows]
-                row_str = " \\quad & ".join(
-                    [f"{latex(Symbol(var_name))} & = {value}" for var_name, value in row]
-                )
-                # Add placeholders for missing variables in the row
-                if len(row) < rows & rows!=1:
-                    row_str += " \\quad & " * (rows - len(row)) + " \n"
-
-                markdown_str += row_str + " \\\\ \n"
-        # strip the last space
-        if markdown_str.endswith(" \\\\ \n"):
-            markdown_str = markdown_str[:-4]
-        markdown_str += "\\end{aligned}\n$$"
-
-    else:
-        markdown_str = ""
-        for var_name, value in formatted_vars.items():
-            markdown_str += f"$${latex(Symbol(var_name))} = {value}$$\n\n"
-
-    display(Markdown(markdown_str))
-
+        # Handle the 'sum_' exception
+        if part == 'sum' and i + 1 < len(name_parts) and name_parts[i + 1] == '_':
+            result_parts.append(symbols.get(part, part))
+            i += 1  # Skip the underscore after 'sum'
+
+        # Handle the '_strich' exception
+        elif part == '_' and i + 1 < len(name_parts) and name_parts[i + 1] == 'apos':
+            result_parts.append(symbols.get(name_parts[i + 1], name_parts[i + 1]))
+            i += 1  # Skip both underscore and 'strich'
+
+        # Replace regular parts using the dictionary
+        elif part in symbols:
+            result_parts.append(symbols[part])
+        
+        # Preserve numbers and non-matching underscores
+        else:
+            result_parts.append(part)
+        
+        i += 1
 
-def dict_to_markdown_table(data: dict) -> str:
-    if not data:
-        return ""
-    
-    # Extract keys and values
-    items = list(data.items())
-    rows = []
-    
-    # Pair items into rows with 4 columns (2 key-value pairs per row)
-    for i in range(0, len(items), 2):
-        row = []
-        for j in range(2):
-            if i + j < len(items):
-                key, value = items[i + j]
-                row.extend([str(key), str(value)])
-            else:
-                row.extend(["-", "-"])  # Fill empty cells for incomplete rows
-        rows.append(row)
-    
-    # Headers for the 4 columns
-    headers = ["Bezeichnung", "Wert", "Bezeichnung", "Wert"]
-    
-    # Calculate column widths
-    col_widths = [max(len(row[i]) for row in [headers] + rows) for i in range(4)]
+    # Join all parts back together
+    name_replaced = ''.join(result_parts)
 
-    # Create the markdown table
-    table = []
+    # make a symbol out of it
+    name_replaced = latex(Symbol(name_replaced))
+
+    return name_replaced
 
-    # Header row
-    header_row = "| " + " | ".join(headers[i].ljust(col_widths[i]) for i in range(4)) + " |"
-    table.append(header_row)
+def format_value(value, precision: float = 2):
+    """Formats the value based on its type."""
+    if isinstance(value, (int, float)):
+        return round(value, precision)
 
-    # Divider
-    divider = "| " + " | ".join("-" * col_widths[i] for i in range(4)) + " |"
-    table.append(divider)
+    elif isinstance(value, np.ndarray):
+        # Handle numpy arrays as matrices
+        rounded_value = np.round(value, precision)
+        matrix = Matrix(rounded_value.tolist())
+        return latex(matrix)
 
-    # Data rows
-    for row in rows:
-        row_str = "| " + " | ".join(row[i].ljust(col_widths[i]) for i in range(4)) + " |"
-        table.append(row_str)
+    elif isinstance(value, list):
+        # Handle lists as vectors
+        formatted_list = [format_value(item, precision) for item in value]
+        return formatted_list
 
-    return "\n".join(table)
+    elif hasattr(value, "magnitude"):
+        # Handle Pint quantities
+        magnitude = np.round(value.magnitude, precision)
+        if isinstance(magnitude, np.ndarray):
+            # Handle numpy arrays of Pint quantities as matrices
+            magnitude_str = np.array2string(magnitude, separator=",")
+            return f"{latex(Matrix(magnitude.tolist()))} \\ {latex(Symbol(str(value.units)))}"
+        else:
+            # Handle scalar Pint quantities
+            return f"{magnitude} \\ {latex(Symbol(str(value.units)))}"
+    else:
+        return value
+
+def dict_to_markdown_table(dict:dict, symbols: dict= special_characters, precision:int=2, tablefmt: str='pipe'):
+    # Convert dictionary to list of lists with appropriate headers
+    formatted_data = [[key, '$'+str(format_value(value, precision))+'$'] for key, value in dict.items()]
+    headers = ['Bezeichnung', 'Wert']
+
+    # Generate the Markdown table
+    markdown_table = tabulate(formatted_data, headers=headers, tablefmt=tablefmt)
+
+    return markdown_table
+
+
+
+def put_out(precision: int = 2, offset: int = 0, rows: int = 3, symbols: dict = special_characters, tablefmt:str = 'pipe') -> None:
+    """
+    Renders the variables and their values as LaTeX equations in a Jupyter notebook.
+
+    Args:
+        precision (int): The precision for numerical values. Defaults to 2.
+        offset (int): The number of previous cells to include for variable extraction. Defaults to 0.
+        rows (int): Maximum number of equations per row in horizontal display. Defaults to 3.
+        symbols (dict): Dictionary of symbols for LaTeX formatting.
+
+    Returns:
+        None
+    """
+    # Use the new cell parser function
+    variables = parse_cell_variables(offset)
+
+
+    formatted_vars = {}
+
+    for name, value in variables.items():
+        if type(value) == dict:
+            display(Markdown(dict_to_markdown_table(value, precision=precision, tablefmt=tablefmt)))
+            
+        else:
+            formatted_vars.update({format_name(name, symbols=symbols): format_value(value, precision=precision)})
+
+    # Horizontal display with aligned '=' signs
+    var_list = list(formatted_vars.items())
+
+    if len(var_list) == 0:
+        return 
+    elif len(var_list) < rows:
+        rows = len(var_list)
+
+    markdown_str = "$$\n\\begin{aligned}\n"
+    for i in range(0, len(var_list), rows):
+        row = var_list[i : i + rows]
+        row_str = " \\quad & ".join(
+            [f"{var_name} & = {value}" for var_name, value in row]
+        )
+        if len(row) < rows and rows != 1:
+            row_str += " \\quad & " * (rows - len(row)) + " \n"
+
+        markdown_str += row_str + " \\\\ \n"
+
+    if markdown_str.endswith(" \\\\ \n"):
+        markdown_str = markdown_str[:-4]
+    markdown_str += "\\end{aligned}\n$$"
+
+    display(Markdown(markdown_str))
+
+
 

engicalc/units.py

@@ -6,7 +6,7 @@
 
 # Erstellen eines UnitRegistry-Objekts
 ureg = UnitRegistry()
-ureg.formatter.default_format = "~P"
+ureg.formatter.default_format = "~L"
 
 # Definition aller relevanten Einheiten
 kg = ureg.kg

setup.py

@@ -2,12 +2,15 @@
 
 setup(
     name='engicalc',
-    version='0.1.0',
+    version='v0.0.1',
     packages=find_packages(),
     install_requires=[
         # List your package dependencies here
-        'numpy', 
-        'sympy',
+        'numpy>=1.26.4', 
+        'sympy>=1.12.1',
+        'jupyter>=1.0.0',
+        'pint @ git+https://github.com/PascalGitz/pint.git',
+        'tabulate'
     ],
     entry_points={
         'console_scripts': [