rubberize 0.1.0__tar.gz

rubberize-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chito Peralta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rubberize-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.2
+Name: rubberize
+Version: 0.1.0
+Summary: Turn Python calculations into well-formatted, math-rich documents.
+Author-email: Chito Peralta <chitoangeloperalta@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Chito Peralta
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: repository, https://github.com/chitoperalta/rubberize
+Project-URL: homepage, https://github.com/chitoperalta/rubberize
+Keywords: latex,markdown,jupyter,notebook,math,engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: markdown<4.0,>=3.7
+Requires-Dist: titlecase<3.0.0,>=2.4.1
+Provides-Extra: notebook
+Requires-Dist: ipython<10.0.0,>=9.0.2; extra == "notebook"
+Requires-Dist: playwright<2.0.0,>=1.51.0; extra == "notebook"
+Provides-Extra: dev
+Requires-Dist: ipython<10.0.0,>=9.0.2; extra == "dev"
+Requires-Dist: playwright<2.0.0,>=1.51.0; extra == "dev"
+Requires-Dist: jupyterlab<5.0.0,>=4.3.6; extra == "dev"
+Requires-Dist: pint<0.25.0,>=0.24.4; extra == "dev"
+Requires-Dist: sympy<2.0.0,>=1.13.3; extra == "dev"
+Requires-Dist: numpy<3.0.0,>=2.2.4; extra == "dev"
+
+# Rubberize
+
+**Turn Python calculations into well-formatted, math-rich documents.**
+
+## Installation
+
+Install Rubberize with `pip`:
+
+```bash
+pip install rubberize
+```
+
+Rubberize is primarily built for Jupyter. To enable notebook magics:
+
+```bash
+pip install rubberize[notebook]
+```
+
+## Basic Usage
+
+### In Modules
+
+Here's a quick example of how to use Rubberize:
+
+```python
+import rubberize
+
+source = """\
+a + b
+a - b
+"""
+
+namespace = {"a": 1, "b": 2}
+stmts_latex = rubberize.latexer(source, namespace)
+```
+
+`stmts_latex` will be a list of `StmtLatex` objects that contain LaTeX representations of each statement.
+
+### In Notebooks
+
+Rubberize is more impressive in notebooks (assuming `rubberize[notebooks]` is installed). In a Code cell, use `%%tap` and your code in the cell will be displayed as math notation, along with substitutions, results, and comments.
+
+## Contributing
+
+To set up a development environment, install the supported dependencies:
+
+```bash
+pip install rubberize[dev]
+```
+
+## License
+
+MIT License © 2025 [Chito Peralta](mailto:chitoangeloperalta@gmail.com)
+

rubberize-0.1.0/README.md

@@ -0,0 +1,54 @@
+# Rubberize
+
+**Turn Python calculations into well-formatted, math-rich documents.**
+
+## Installation
+
+Install Rubberize with `pip`:
+
+```bash
+pip install rubberize
+```
+
+Rubberize is primarily built for Jupyter. To enable notebook magics:
+
+```bash
+pip install rubberize[notebook]
+```
+
+## Basic Usage
+
+### In Modules
+
+Here's a quick example of how to use Rubberize:
+
+```python
+import rubberize
+
+source = """\
+a + b
+a - b
+"""
+
+namespace = {"a": 1, "b": 2}
+stmts_latex = rubberize.latexer(source, namespace)
+```
+
+`stmts_latex` will be a list of `StmtLatex` objects that contain LaTeX representations of each statement.
+
+### In Notebooks
+
+Rubberize is more impressive in notebooks (assuming `rubberize[notebooks]` is installed). In a Code cell, use `%%tap` and your code in the cell will be displayed as math notation, along with substitutions, results, and comments.
+
+## Contributing
+
+To set up a development environment, install the supported dependencies:
+
+```bash
+pip install rubberize[dev]
+```
+
+## License
+
+MIT License © 2025 [Chito Peralta](mailto:chitoangeloperalta@gmail.com)
+

rubberize-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "rubberize"
+version = "0.1.0"
+description = "Turn Python calculations into well-formatted, math-rich documents."
+authors = [
+    {name = "Chito Peralta", email = "chitoangeloperalta@gmail.com"}
+]
+keywords = ["latex", "markdown", "jupyter", "notebook", "math", "engineering"]
+license = {file = "LICENSE"}
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "markdown>=3.7,<4.0",
+    "titlecase>=2.4.1,<3.0.0"
+]
+
+[project.optional-dependencies]
+notebook = [
+    "ipython>=9.0.2,<10.0.0",
+    "playwright>=1.51.0,<2.0.0"
+]
+dev = [
+    "ipython>=9.0.2,<10.0.0",
+    "playwright>=1.51.0,<2.0.0",
+    "jupyterlab>=4.3.6,<5.0.0",
+    "pint>=0.24.4,<0.25.0",
+    "sympy>=1.13.3,<2.0.0",
+    "numpy>=2.2.4,<3.0.0",
+]
+
+[project.urls]
+repository = "https://github.com/chitoperalta/rubberize"
+homepage = "https://github.com/chitoperalta/rubberize"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["rubberize"]

rubberize-0.1.0/rubberize/__init__.py

@@ -0,0 +1,38 @@
+"""Rubberize turns Python calculations into well-formatted, math-rich
+documents.
+"""
+
+__version__ = "0.1.0"
+
+from rubberize.config import config
+
+from rubberize.latexer import (
+    latexer,
+    CalcSheet,
+    Table,
+    register_call_converter,
+    register_object_converter,
+)
+
+try:
+    # If Pint is installed:
+    from rubberize.latexer import register_units_latex
+except ImportError:
+    pass
+
+from rubberize.render import render
+
+try:
+    # If IPython is installed:
+    from rubberize.load_ipython_extension import load_ipython_extension
+except ImportError:
+    pass
+
+try:
+    # If exporter deps are installed:
+    from rubberize.export_notebook import (
+        export_notebook_to_html,
+        export_notebook_to_pdf,
+    )
+except ImportError:
+    pass

rubberize-0.1.0/rubberize/config.py

@@ -0,0 +1,203 @@
+"""Config system.
+
+The configuration is a singleton instance of `_Config`.
+"""
+
+import ast
+import json
+from contextlib import contextmanager
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import Any, Iterable, Literal, Optional
+
+from rubberize import exceptions
+
+
+@dataclass
+class _ConfigDefaults:  # pylint: disable=too-many-instance-attributes
+    """Default config."""
+
+    # Name
+    use_subscripts: bool = True
+    use_symbols: bool = True
+
+    # Display modes
+    show_definition: bool = True
+    show_substitution: bool = True
+    show_result: bool = True
+
+    # String display options
+    str_font: Literal["", "bf", "it", "rm", "sf", "tt"] = ""
+
+    # Number display options
+    num_format: Literal["FIX", "SCI", "GEN", "ENG"] = "FIX"
+    num_format_prec: int = 2
+    num_format_max_digits: int = 15
+    num_format_e_not: bool = False
+    thousands_separator: Literal["", " ", ",", ".", "'"] = " "
+    decimal_marker: Literal[".", ","] = "."
+
+    use_polar: bool = False
+    use_polar_deg: bool = True
+
+    use_inline_units: bool = True
+    use_dms_units: bool = False
+    use_fif_units: bool = False
+    fif_prec: int = 16
+
+    # Expressions
+    wrap_indices: bool = True
+    convert_special_funcs: bool = True
+    use_contextual_mult: bool = True
+    hidden_modules: set[str] = field(
+        default_factory=lambda: {"math", "sp", "np", "ureg"}
+    )
+    show_list_as_col: bool = True
+    show_tuple_as_col: bool = False
+    show_set_as_col: bool = False
+    show_dict_as_col: bool = True
+
+    # Statements
+    multiline: bool = False
+
+
+class _Config(_ConfigDefaults):
+    """Singleton global configuration."""
+
+    def __init__(self):
+        super().__init__()
+        self.load()
+
+    def set(self, **kwargs: bool | int | Iterable[str]) -> None:
+        """Update multiple config values passed as keyword arguments."""
+
+        for key, value in kwargs.items():
+            if not hasattr(self, key):
+                raise AttributeError(f"Invalid config key: {key}")
+
+            if key == "hidden_modules":
+                if not isinstance(value, (set, list, tuple)):
+                    raise TypeError(f"Invalid {key} type: {type(value)}")
+                value = set(value)
+
+            setattr(self, key, value)
+
+    def load(self, *args: str, path: Optional[str | Path] = None) -> None:
+        """Load config from defaults or a specified JSON file.
+
+        If a file exists for a given `path`, its contents are loaded and
+        used to update the config. Otherwise, default values are used.
+
+        Args:
+            *args: If provided, only the specified keys are updated.
+            path: Path to the JSON file. If `None`, the default values
+                are used.
+        """
+
+        data = asdict(_ConfigDefaults())
+
+        if path is not None:
+            path = Path(path)
+            if path.exists():
+                with path.open("r", encoding="utf-8") as f:
+                    data.update(json.load(f))
+
+        if args:
+            data = {k: data[k] for k in args if k in data}
+        self.set(**data)
+
+    def reset(self, *args: str) -> None:
+        """Reset the config or only the specified keys to defaults."""
+
+        self.load(*args, path=None)
+
+    def save(self, path: str | Path) -> None:
+        """Save the current config to a JSON file."""
+
+        config_dict = asdict(self)
+        config_dict["hidden_modules"] = list(config_dict["hidden_modules"])
+
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        with path.open("w", encoding="utf-8") as f:
+            json.dump(config_dict, f, indent=4)
+
+    def add_hidden_module(self, *modules: str) -> None:
+        """Add one or more modules to `hidden_modules`."""
+
+        self.hidden_modules.update(modules)
+
+    def remove_hidden_module(self, *modules: str) -> None:
+        """Remove one or more modules from `hidden_modules`."""
+
+        self.hidden_modules.difference_update(modules)
+
+    @contextmanager
+    def override(self, **kwargs: bool | int | Iterable[str]):
+        """Temporarily override config values within a context."""
+
+        original_values = {key: getattr(self, key) for key in kwargs}
+
+        try:
+            self.set(**kwargs)
+            yield
+        finally:
+            self.set(**original_values)
+
+
+# fmt: off
+_KEYWORDS: dict[str, dict[str, Any]] = {
+    "none": {"show_definition": False, "show_substitution": False, "show_result": False},
+    "all": {"show_definition": True, "show_substitution": True, "show_result": True},
+    "def": {"show_definition": True, "show_substitution": False, "show_result": False},
+    "sub": {"show_definition": False, "show_substitution": True, "show_result": False},
+    "res": {"show_definition": False, "show_substitution": False, "show_result": True},
+    "nodef": {"show_definition": False, "show_substitution": True, "show_result": True},
+    "nosub": {"show_definition": True, "show_substitution": False, "show_result": True},
+    "nores": {"show_definition": True, "show_substitution": True, "show_result": False},
+    "line": {"multiline": False},
+    "stack": {"multiline": True},
+    "fix": {"num_format": "FIX"},
+    "sci": {"num_format": "SCI"},
+    "gen": {"num_format": "GEN"},
+    "eng": {"num_format": "ENG"},
+    "0": {"num_format_prec": 0},
+    "1": {"num_format_prec": 1},
+    "2": {"num_format_prec": 2},
+    "3": {"num_format_prec": 3},
+    "4": {"num_format_prec": 4},
+    "5": {"num_format_prec": 5},
+    "6": {"num_format_prec": 6},
+}
+# fmt: on
+
+
+def parse_modifiers(modifiers: list[str]) -> dict[str, Any]:
+    """Parse a list of modifiers to an overrides dict for use with
+    `config.override()`.
+    """
+
+    override_dict = {}
+    for modifier in modifiers:
+        modifier = modifier.removeprefix("@")
+
+        if modifier == "hide":
+            return {"hide": ...}
+        if modifier == "endhide":
+            return {"endhide": ...}
+
+        if "=" in modifier:
+            key, value = modifier.split("=", 1)
+            override_dict[key] = ast.literal_eval(value)
+        elif modifier in _KEYWORDS:
+            override_dict.update(_KEYWORDS[modifier])
+        else:
+            raise exceptions.RubberizeKeywordError(
+                f"Unknown keyword: '{modifier}'"
+            )
+    return override_dict
+
+
+# Singleton instance
+config = _Config()

rubberize-0.1.0/rubberize/exceptions.py

@@ -0,0 +1,33 @@
+"""Custom exceptions for the library."""
+
+
+class RubberizeError(Exception):
+    """Base class for all rubberize exceptions."""
+
+
+class RubberizeNotImplementedError(RubberizeError):
+    """This error is raised when the user attempts to use a feature that
+    is currently not implemented (but may be implemented in the future).
+    """
+
+
+class RubberizeTypeError(RubberizeError, TypeError):
+    """This error is raised when the user attempts to pass the wrong
+    argument type.
+    """
+
+
+class RubberizeValueError(RubberizeError, ValueError):
+    """This error is raised when the user attempts to pass the wrong
+    argument value of correct type.
+    """
+
+
+class RubberizeSyntaxError(RubberizeError, SyntaxError):
+    """This error is raised when the user uses a feature incorrectly, or
+    attempts to use a feature that will not be implemented.
+    """
+
+
+class RubberizeKeywordError(RubberizeError, KeyError):
+    """This error is raised when the user uses an unknown mapping key."""

rubberize-0.1.0/rubberize/export_notebook.py

@@ -0,0 +1,189 @@
+"""Functions to export IPython notebooks."""
+
+import asyncio
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import nest_asyncio
+from playwright.sync_api import sync_playwright, Error
+from playwright.async_api import async_playwright
+
+
+_MATHJAX_WAITER = """
+(function() {
+    if (typeof MathJax !== 'undefined' && MathJax.Hub) {
+        MathJax.Hub.Queue(["Typeset", MathJax.Hub]);
+
+        return new Promise((resolve, reject) => {
+            MathJax.Hub.Queue(() => {
+                if (MathJax.Hub.Queue.length === 0) {
+                    setTimeout(() => {
+                        resolve(true);
+                    }, 500);  // Wait for 500ms before resolve
+                } else {
+                    reject('MathJax is still rendering');
+                }
+            });
+        });
+    }
+    return false;
+})()
+"""
+
+
+def export_notebook_to_html(
+    path: str | Path,
+    output: Optional[str | Path] = None,
+    *,
+    no_input: bool = True,
+) -> None:
+    """Export a Jupyter notebook to HTML using `nbconvert`.
+
+    Args:
+        path: The path to the notebook to convert.
+        output: Optional output path. If `None`, uses the input path but
+            with file extension changed to `.html`.
+        no_input: Whether to exclude input cells in the output. Defaults
+            to `True`.
+    """
+
+    path = Path(path)
+    output = Path(output) if output else path.with_suffix(".html")
+
+    subprocess.run(
+        [
+            "jupyter",
+            "nbconvert",
+            "--to",
+            "html",
+            "--no-input" if no_input else "",
+            str(path),
+            "--output",
+            str(output),
+        ],
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def _html_to_pdf(path: str | Path, output: Optional[str | Path] = None) -> None:
+    """Export an HTML file to PDF.
+
+    Use Playwright to open the HTML file, wait for MathJax to render,
+    and print it to PDF.
+    """
+
+    path = Path(path)
+    output = Path(output) if output else path.with_suffix(".pdf")
+
+    try:
+        _html_to_pdf_sync(path, output)
+    except Error:
+        if sys.platform.startswith("win"):
+            # Fix for windows, probably.
+            asyncio.set_event_loop_policy(
+                asyncio.WindowsSelectorEventLoopPolicy()  # type: ignore
+            )
+        loop = asyncio.get_running_loop()
+        if loop.is_running():
+            # Use nest_asyncio to allow nested loops (e.g. in Jupyter)
+            nest_asyncio.apply()
+            new_loop = asyncio.new_event_loop()
+            new_loop.run_until_complete(_html_to_pdf_async(path, output))
+            new_loop.close()
+        else:
+            loop.run_until_complete(_html_to_pdf_async(path, output))
+
+
+def _html_to_pdf_sync(path: Path, output: str | Path) -> None:
+    """Sync version of Playwright routine."""
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=True)
+        try:
+            page = browser.new_page()
+            page.goto(f"file:///{path.resolve().as_posix()}")
+            page.wait_for_function(_MATHJAX_WAITER)
+            page.pdf(path=output, prefer_css_page_size=True, outline=True)
+        finally:
+            browser.close()
+
+
+async def _html_to_pdf_async(path: Path, output: str | Path) -> None:
+    """Async version of Playwright routine."""
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        try:
+            page = await browser.new_page()
+            await page.goto(f"file:///{path.resolve().as_posix()}")
+            await page.wait_for_function(_MATHJAX_WAITER)
+            await page.pdf(path=output, prefer_css_page_size=True, outline=True)
+        finally:
+            await browser.close()
+
+
+def export_notebook_to_pdf(
+    path: str | Path,
+    output: Optional[str | Path] = None,
+    *,
+    no_input: bool = True,
+) -> None:
+    """Export a Jupyter notebook to PDF using nbconvert and Playwright.
+    if a directory is supplied as input, all notebooks in the directory
+    will be exported.
+
+    Args:
+        path: The path to the notebook or directory to convert.
+        output: Optional output path. If `None`, uses the input path but
+            with file extension changed to `.pdf`, or if input path is a
+            directory, the output will be saved in a new sibling dir
+            named `{{dir}}_pdf`.
+        no_input: Whether to exclude input cells in the output. Defaults
+            to `True`.
+    """
+
+    path = Path(path)
+
+    if path.is_dir():
+        output = Path(output) if output else path.parent / f"{path.name}_pdf"
+        output.mkdir(parents=True, exist_ok=True)
+
+        notebooks = list(path.glob("*.ipynb"))
+        if not notebooks:
+            print(f"No notebooks found in {path.name}")
+            return
+
+        for notebook in notebooks:
+            output_pdf = output / notebook.with_suffix(".pdf").name
+            export_notebook_to_pdf(notebook, output_pdf, no_input=no_input)
+
+        print(
+            f"\nAll notebooks  in {path.name} converted."
+            f"PDFs saved to: {output}"
+        )
+
+    elif path.is_file() and path.suffix == ".ipynb":
+        # Handle single notebook file
+        output = Path(output) if output else path.with_suffix(".pdf")
+
+        print(f"Converting: {path}")
+
+        # Create a temp file for the HTML output
+        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as tmp:
+            tmp_path = Path(tmp.name)
+
+        try:
+            export_notebook_to_html(path, tmp_path, no_input=no_input)
+            _html_to_pdf(tmp_path, output)
+            print(f"PDF saved as: {output}")
+        finally:
+            # Ensure deletion of temp file
+            tmp_path.unlink(missing_ok=True)
+
+    else:
+        print(f"Invalid input: {path} is not a notebook or directory.")

rubberize-0.1.0/rubberize/load_ipython_extension.py

@@ -0,0 +1,27 @@
+"""Loads the calcsetter extension features into IPython."""
+
+import os
+
+from IPython.core.display import display_html
+from IPython.core.interactiveshell import InteractiveShell
+
+from rubberize.magics import RubberizeMagics
+
+
+def load_ipython_extension(ipython: InteractiveShell) -> None:
+    """Load the IPython extension.
+
+    This function is not to be called directly. It executed by the
+    %load_ext line magic in the IPython InteractiveShell. It registers
+    the magics of the library.
+    """
+    ipython.register_magics(RubberizeMagics)
+    _load_css(os.path.join(os.path.dirname(__file__), "static", "styles.css"))
+
+
+def _load_css(path: str) -> None:
+    """Load a CSS stylesheet into IPython."""
+
+    with open(path, "r", encoding="utf-8") as file:
+        css = file.read()
+    display_html(f"<style>{css}</style>", raw=True)

rubberize-0.1.0/rubberize/magics.py

@@ -0,0 +1,118 @@
+"""The class for all magic commands that the library adds to the
+Interactive Shell. Called by `load_ipython_extension()`
+"""
+
+from typing import Any, Optional
+
+from IPython.core.display import display_html
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.magic import (
+    Magics,
+    cell_magic,
+    magics_class,
+    needs_local_scope,
+)
+from IPython.core.magic_arguments import (
+    argument,
+    magic_arguments,
+    parse_argstring,
+)
+from IPython.utils.capture import capture_output
+
+import rubberize.vendor.ast_comments as ast_c
+
+from rubberize.config import config
+from rubberize.latexer.latexer import latexer
+from rubberize.render.render import render
+from rubberize.config import parse_modifiers
+
+
+@magics_class
+class RubberizeMagics(Magics):
+    """Contains IPython magics to be loaded."""
+
+    @magic_arguments()
+    @argument(
+        "--dead",
+        action="store_true",
+        help="dead cell -- the cell is not run; only rendered.",
+    )
+    @cell_magic
+    def ast(self, line: str, cell: str) -> None:
+        """Magic to run the cell and dump it as AST for debugging."""
+
+        assert isinstance(self.shell, InteractiveShell)
+
+        args = parse_argstring(self.tap, line)
+        if not args.dead:
+            with capture_output():
+                run_result = self.shell.run_cell(cell)
+            if not run_result.success:
+                return None
+
+        # Ignore line magics
+        cleaned_cell = "\n".join(
+            l for l in cell.split("\n") if not l.startswith("%")
+        )
+
+        return print(ast_c.dump(ast_c.parse(cleaned_cell), indent=4))
+
+    @magic_arguments()
+    @argument(
+        "modifiers",
+        nargs="*",
+        help="keyword shortcuts or config option assignments for the cell",
+    )
+    @argument(
+        "--grid",
+        "-g",
+        action="store_true",
+        help="render the cell in a grid and without descriptions",
+    )
+    @argument(
+        "--html",
+        "-h",
+        action="store_true",
+        help="print the html output for debugging",
+    )
+    @argument(
+        "--dead",
+        action="store_true",
+        help="dead cell -- the cell is not run; only rendered.",
+    )
+    @needs_local_scope
+    @cell_magic
+    def tap(
+        self, line: str, cell: str, local_ns: Optional[dict[str, Any]]
+    ) -> None:
+        """Magic to run the cell and render it as mathematical notation.
+        It supports line args to customize the output.
+        """
+
+        assert isinstance(self.shell, InteractiveShell)
+
+        args = parse_argstring(self.tap, line)
+        override = parse_modifiers(args.modifiers)
+        if "hide" in override:
+            return None
+
+        if not args.dead:
+            with capture_output():
+                run_result = self.shell.run_cell(cell)
+            if not run_result.success:
+                return None
+        else:
+            local_ns = None
+
+        # Ignore line magics
+        cleaned_cell = "\n".join(
+            l for l in cell.split("\n") if not l.startswith("%")
+        )
+
+        with config.override(**override):
+            latex_list = latexer(cleaned_cell, local_ns)
+            cell_html = render(latex_list, local_ns, grid=args.grid)
+
+        if args.html:
+            return print(cell_html, "\n")
+        return display_html(cell_html, raw=True)

rubberize-0.1.0/rubberize/utils.py

@@ -0,0 +1,123 @@
+"""Utility functions used throughout the library."""
+
+import re
+import textwrap
+from typing import Any, Callable, Literal, Optional
+
+
+_FlagsType = re.RegexFlag | Literal[0]
+
+
+def find_and_sub(
+    pattern: str | re.Pattern[str],
+    repl: str | Callable[[re.Match[str]], str],
+    string: str,
+    group: int = 1,
+    flags: _FlagsType = 0,
+) -> tuple[list[str | Any], str]:
+    """Find occurrences of a pattern in a string, extract matches from
+    the specified capturing group, and perform a substitution.
+
+    Args:
+        pattern: The regex pattern to search for.
+        repl: The replacement string or a function that takes a match
+            object and returns a replacement string.
+        string: The input string to search within.
+        group: The capturing group whose matches should be extracted.
+        flags: Regex flags modifying the search behavior.
+
+    Returns:
+        A tuple containing a list of matches from the capturing group,
+        and the string after performing the substitution.
+    """
+    matches = [m.group(group) for m in re.finditer(pattern, string, flags)]
+    return matches, re.sub(pattern, repl, string, flags)
+
+
+def wrap_delims(
+    text: str,
+    delims: tuple[str, str],
+    *,
+    force_block: bool = False,
+    spaced_line: bool = False,
+    indent: int = 4,
+) -> str:
+    """Wrap text with a pair of delimiters, optionally formatting it as
+    a block.
+
+    Default behavior, for delims `"{{...}}"`:
+    - `""` -> `"{{}}"`
+    - `"text 1\\ntext 2"` -> `"{{\\n    text 1\\n    text 2\\n}}"`
+    - `"text"` -> `"{{text}}"`
+
+    Args:
+        text: The text to be wrapped.
+        delims: A tuple specifying the opening and closing delimiters.
+        force_block: If True, forces block formatting even for single
+            line input.
+        spaced_line: If True, adds spaces between delimiters and text
+            when inline.
+        indent: The number of spaces to indent each line when using
+            block format.
+
+    Returns:
+        The text wrapped with the given delimiters.
+    """
+
+    if not text:
+        return delims[0] + delims[1]
+    if force_block or ("\n" in text):
+        text = textwrap.indent(text, " " * indent)
+        return delims[0] + "\n" + text + "\n" + delims[1]
+    if spaced_line:
+        return delims[0] + " " + text + " " + delims[1]
+    return delims[0] + text + delims[1]
+
+
+def html_tag(
+    tag: str,
+    content: str | list[str],
+    *,
+    force_block=False,
+    indent: int = 4,
+    **kwargs: Optional[str],
+) -> str:
+    """Wrap content in an HTML tag. Supports attributes and block
+    formatting.
+
+    Notes:
+    - If `content` is a list, it is joined into a single string with
+        line breaks.
+    - Attributes with a leading underscore (`_class`) are stripped of
+        the underscore.
+
+    Args:
+        tag: The HTML tag name.
+        content: The text or list of strings to wrap within the tag.
+        force_block: If True, forces block formatting even for single
+            line content.
+        indent: The number of spaces to indent block content.
+        **kwargs: Optional HTML attributes as key-value pairs.
+
+    Returns:
+        A string representing the formatted HTML element.
+    """
+
+    if isinstance(content, list):
+        content = "\n".join(content)
+
+    open_tag = f"<{tag}"
+    for attr, value in kwargs.items():
+        open_tag += (
+            f' {attr.lstrip("_")}="{value}"' if value is not None else ""
+        )
+    open_tag += ">"
+    close_tag = f"</{tag}>"
+
+    return wrap_delims(
+        content,
+        (open_tag, close_tag),
+        force_block=force_block,
+        spaced_line=False,
+        indent=indent,
+    )

rubberize-0.1.0/rubberize.egg-info/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.2
+Name: rubberize
+Version: 0.1.0
+Summary: Turn Python calculations into well-formatted, math-rich documents.
+Author-email: Chito Peralta <chitoangeloperalta@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Chito Peralta
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: repository, https://github.com/chitoperalta/rubberize
+Project-URL: homepage, https://github.com/chitoperalta/rubberize
+Keywords: latex,markdown,jupyter,notebook,math,engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: markdown<4.0,>=3.7
+Requires-Dist: titlecase<3.0.0,>=2.4.1
+Provides-Extra: notebook
+Requires-Dist: ipython<10.0.0,>=9.0.2; extra == "notebook"
+Requires-Dist: playwright<2.0.0,>=1.51.0; extra == "notebook"
+Provides-Extra: dev
+Requires-Dist: ipython<10.0.0,>=9.0.2; extra == "dev"
+Requires-Dist: playwright<2.0.0,>=1.51.0; extra == "dev"
+Requires-Dist: jupyterlab<5.0.0,>=4.3.6; extra == "dev"
+Requires-Dist: pint<0.25.0,>=0.24.4; extra == "dev"
+Requires-Dist: sympy<2.0.0,>=1.13.3; extra == "dev"
+Requires-Dist: numpy<3.0.0,>=2.2.4; extra == "dev"
+
+# Rubberize
+
+**Turn Python calculations into well-formatted, math-rich documents.**
+
+## Installation
+
+Install Rubberize with `pip`:
+
+```bash
+pip install rubberize
+```
+
+Rubberize is primarily built for Jupyter. To enable notebook magics:
+
+```bash
+pip install rubberize[notebook]
+```
+
+## Basic Usage
+
+### In Modules
+
+Here's a quick example of how to use Rubberize:
+
+```python
+import rubberize
+
+source = """\
+a + b
+a - b
+"""
+
+namespace = {"a": 1, "b": 2}
+stmts_latex = rubberize.latexer(source, namespace)
+```
+
+`stmts_latex` will be a list of `StmtLatex` objects that contain LaTeX representations of each statement.
+
+### In Notebooks
+
+Rubberize is more impressive in notebooks (assuming `rubberize[notebooks]` is installed). In a Code cell, use `%%tap` and your code in the cell will be displayed as math notation, along with substitutions, results, and comments.
+
+## Contributing
+
+To set up a development environment, install the supported dependencies:
+
+```bash
+pip install rubberize[dev]
+```
+
+## License
+
+MIT License © 2025 [Chito Peralta](mailto:chitoangeloperalta@gmail.com)
+

rubberize-0.1.0/rubberize.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+rubberize/__init__.py
+rubberize/config.py
+rubberize/exceptions.py
+rubberize/export_notebook.py
+rubberize/load_ipython_extension.py
+rubberize/magics.py
+rubberize/utils.py
+rubberize.egg-info/PKG-INFO
+rubberize.egg-info/SOURCES.txt
+rubberize.egg-info/dependency_links.txt
+rubberize.egg-info/requires.txt
+rubberize.egg-info/top_level.txt

rubberize-0.1.0/rubberize.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rubberize-0.1.0/rubberize.egg-info/requires.txt

@@ -0,0 +1,14 @@
+markdown<4.0,>=3.7
+titlecase<3.0.0,>=2.4.1
+
+[dev]
+ipython<10.0.0,>=9.0.2
+playwright<2.0.0,>=1.51.0
+jupyterlab<5.0.0,>=4.3.6
+pint<0.25.0,>=0.24.4
+sympy<2.0.0,>=1.13.3
+numpy<3.0.0,>=2.2.4
+
+[notebook]
+ipython<10.0.0,>=9.0.2
+playwright<2.0.0,>=1.51.0

rubberize-0.1.0/rubberize.egg-info/top_level.txt

@@ -0,0 +1 @@
+rubberize

rubberize-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+