unit-syntax 0.2.1__tar.gz → 0.2.2__tar.gz

{unit_syntax-0.2.1 → unit_syntax-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unit-syntax
-Version: 0.2.1
+Version: 0.2.2
 Summary: Physical unit literals for Jupyter and IPython
 Home-page: https://github.com/ahupp/unit-syntax
 Author: Adam Hupp
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 10 meter
 ```
 
-Why? I often use Python as an interactive calculator for physical problems, and wished it had the type safety of explicit units along with the readability of normal notation.
+Why? I often use Python as an interactive calculator for physical problems and wished it had the type safety of explicit units along with the readability of normal notation.
 
 `unit-syntax` currently supports Jupyter notebooks and the IPython interpreter; maybe someday support for standalone scripts.
 
@@ -42,7 +42,7 @@ $ pip install unit-syntax
 To enable unit-syntax in a Jupyter/IPython session run:
 
 ```python
-import unit_syntax.ipython
+%load_ext unit_syntax
 ```
 
 Tip: In Jupyter this must be run in its own cell before any units expressions are evaluated.
@@ -105,30 +105,18 @@ The parser is [pegen](https://we-like-parsers.github.io/pegen/), which is the sa
 
 Syntax transformation in IPython/Jupyter uses [IPython custom input transformers](https://ipython.readthedocs.io/en/stable/config/inputtransforms.html).
 
-````python
-
-An IPython [custom input transformer](https://ipython.readthedocs.io/en/stable/config/inputtransforms.html) parses the new syntax using a modified version of the official Python grammar, and translates it into calls to the excellent [Pint](https://pint.readthedocs.io/) units library.
-
 ## Why only allow units on simple expressions?
 
-The rule for applying units only to "simple" expressions rather than treating it as a typical operator is to avoid unintentional error. Imagine units were instead parsed as operator with high precedence and you wrote this reasonable looking expression:
+Imagine units were instead parsed as operator with high precedence and you wrote this reasonable looking expression:
 
 ```python
 ppi = 300 pixels/inch
 y = x inches * ppi
-````
-
-`inches * ppi` would be parsed as the unit, leading to (at best) a runtime error sometime later and at worst an incorrect calculation. This could be avoided by parenthesizing the expression (e.g. `(x inches) * ppi`, but in general it's too error prone to allow free intermixing of operators and units. (Note: This is not a hypoethical concern, I hit this within 10 minutes of first trying out the idea)
-
-## Help!
-
-If you're getting an unexpected result, try using `unit_syntax.enable_ipython(debug_transform=True)`. This will log the transformed Python code to the console.
-
-If you're stuck, feel free to open an issue.
+```
 
-## How does it work?
+`inches * ppi` would be parsed as the unit, leading to (at best) a runtime error sometime later and at worst an incorrect calculation. This could be avoided by parenthesizing the expression (e.g. `(x inches) * ppi`, but in general it's too error prone to allow free intermixing of operators and units. (Note: This is not a hypothical concern, I hit this within 10 minutes of first trying out the idea)
 
-The parser is derived from the official Python grammar using the same parser generator ([pegen](https://github.com/we-like-parsers/pegen)) as Python itself. The transformer hooks into IPython/Jupyter using [custom input transformers](https://ipython.readthedocs.io/en/stable/config/inputtransforms.html).
+It's easy to detect units used when they aren't allowed (that syntax isn't valid anywhere else), but not generally possible to determine if you forgot parens or meant to write a unit.
 
 ## Prior Art
 
@@ -162,4 +150,5 @@ $ poetry run pytest
 - Typography of output
 - make it work with numba
 - understand how numpy interop works
+- pre-parse units
 

{unit_syntax-0.2.1 → unit_syntax-0.2.2}/README.md

@@ -6,7 +6,7 @@
 10 meter
 ```
 
-Why? I often use Python as an interactive calculator for physical problems, and wished it had the type safety of explicit units along with the readability of normal notation.
+Why? I often use Python as an interactive calculator for physical problems and wished it had the type safety of explicit units along with the readability of normal notation.
 
 `unit-syntax` currently supports Jupyter notebooks and the IPython interpreter; maybe someday support for standalone scripts.
 
@@ -23,7 +23,7 @@ $ pip install unit-syntax
 To enable unit-syntax in a Jupyter/IPython session run:
 
 ```python
-import unit_syntax.ipython
+%load_ext unit_syntax
 ```
 
 Tip: In Jupyter this must be run in its own cell before any units expressions are evaluated.
@@ -86,30 +86,18 @@ The parser is [pegen](https://we-like-parsers.github.io/pegen/), which is the sa
 
 Syntax transformation in IPython/Jupyter uses [IPython custom input transformers](https://ipython.readthedocs.io/en/stable/config/inputtransforms.html).
 
-````python
-
-An IPython [custom input transformer](https://ipython.readthedocs.io/en/stable/config/inputtransforms.html) parses the new syntax using a modified version of the official Python grammar, and translates it into calls to the excellent [Pint](https://pint.readthedocs.io/) units library.
-
 ## Why only allow units on simple expressions?
 
-The rule for applying units only to "simple" expressions rather than treating it as a typical operator is to avoid unintentional error. Imagine units were instead parsed as operator with high precedence and you wrote this reasonable looking expression:
+Imagine units were instead parsed as operator with high precedence and you wrote this reasonable looking expression:
 
 ```python
 ppi = 300 pixels/inch
 y = x inches * ppi
-````
-
-`inches * ppi` would be parsed as the unit, leading to (at best) a runtime error sometime later and at worst an incorrect calculation. This could be avoided by parenthesizing the expression (e.g. `(x inches) * ppi`, but in general it's too error prone to allow free intermixing of operators and units. (Note: This is not a hypoethical concern, I hit this within 10 minutes of first trying out the idea)
-
-## Help!
-
-If you're getting an unexpected result, try using `unit_syntax.enable_ipython(debug_transform=True)`. This will log the transformed Python code to the console.
-
-If you're stuck, feel free to open an issue.
+```
 
-## How does it work?
+`inches * ppi` would be parsed as the unit, leading to (at best) a runtime error sometime later and at worst an incorrect calculation. This could be avoided by parenthesizing the expression (e.g. `(x inches) * ppi`, but in general it's too error prone to allow free intermixing of operators and units. (Note: This is not a hypothical concern, I hit this within 10 minutes of first trying out the idea)
 
-The parser is derived from the official Python grammar using the same parser generator ([pegen](https://github.com/we-like-parsers/pegen)) as Python itself. The transformer hooks into IPython/Jupyter using [custom input transformers](https://ipython.readthedocs.io/en/stable/config/inputtransforms.html).
+It's easy to detect units used when they aren't allowed (that syntax isn't valid anywhere else), but not generally possible to determine if you forgot parens or meant to write a unit.
 
 ## Prior Art
 
@@ -143,3 +131,4 @@ $ poetry run pytest
 - Typography of output
 - make it work with numba
 - understand how numpy interop works
+- pre-parse units

{unit_syntax-0.2.1 → unit_syntax-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unit-syntax"
-version = "0.2.1"
+version = "0.2.2"
 authors = ["Adam Hupp <adam@hupp.org>"]
 packages = [{ include = "unit_syntax" }]
 readme = "README.md"

unit_syntax-0.2.2/unit_syntax/__init__.py

@@ -0,0 +1,14 @@
+import pint
+
+
+# Use the _DEFAULT_REGISTRY so we can interoperate with other pint-using libraries
+ureg = pint._DEFAULT_REGISTRY
+
+
+BOOTSTRAP = """
+import unit_syntax
+_unit_syntax_q = unit_syntax.ureg.Quantity
+"""
+
+
+from .ipython import load_ipython_extension, unload_ipython_extension

unit_syntax-0.2.2/unit_syntax/ipython.py

@@ -0,0 +1,71 @@
+from .transform import transform
+import pint
+
+
+def _add_formatters(ipython):
+    # Overide default formatters to use reduced units.  This lets us keep using the
+    # default registry for interop with other pint-using libraries, but gives more
+    # sensible output in the notebook.
+    def add_formatter(mime, display_fn_name):
+        fn = getattr(pint.Quantity, display_fn_name, None)
+        if fn is None:
+            return
+
+        def fmt_reduced(q, *args):
+            return fn(q.to_reduced_units(), *args)
+
+        formatter = ipython.display_formatter.formatters[mime]
+        formatter.for_type(pint.Quantity, fmt_reduced)
+
+    add_formatter("text/markdown", "_repr_markdown_")
+    add_formatter("text/html", "_repr_html_")
+    add_formatter("text/plain", "_repr_pretty_")
+    add_formatter("text/latex", "_repr_latex_")
+
+
+_has_init_log = False
+_debug = False
+
+
+def transform_lines(lines: list[str]) -> list[str]:
+    """IPython transforms provide a list of strings in the current cell, but to parse correctly we
+    need to parse them as a single string"""
+    return transform("".join(lines)).splitlines(keepends=True)
+
+
+def ipython_transform(lines):
+    ret = transform_lines(lines)
+
+    if _debug:
+        import logging
+
+        global _has_init_log
+        if not _has_init_log:
+            logging.basicConfig(level=logging.DEBUG, force=True)
+        _has_init_log = True
+        logging.debug("unit_syntax: %s -> %s", "\n".join(lines), "\n".join(ret))
+    return ret
+
+
+def load_ipython_extension(ipython):
+    if not hasattr(ipython, "input_transformers_post"):
+        raise ImportError("Unsupported IPython version, version >=7 is required")
+
+    ipython.input_transformers_post.append(ipython_transform)
+
+    _add_formatters(ipython)
+
+    from . import BOOTSTRAP
+
+    ipython.run_cell(BOOTSTRAP)
+
+    try:
+        import matplotlib
+
+        pint.setup_matplotlib(True)
+    except ImportError:
+        pass
+
+
+def unload_ipython_extension(ipython):
+    ipython.input_transformers_post.remove(ipython_transform)

{unit_syntax-0.2.1 → unit_syntax-0.2.2}/unit_syntax/transform.py

@@ -1,12 +1,13 @@
 import ast
-from io import StringIO
-from typing import Iterator, Optional, Generator
 from .parser import parse_string, UnitsExpr
 import pint
-from pprint import pprint
 
 
 class UnitExprTransformer(ast.NodeTransformer):
+    """
+    AST transformer to turn python-with-units into standard python
+    """
+
     ureg: pint.UnitRegistry
 
     def __init__(self, ureg: pint.UnitRegistry):
@@ -22,11 +23,7 @@ class UnitExprTransformer(ast.NodeTransformer):
 
             value = self.generic_visit(node.value)
             return ast.Call(
-                func=ast.Attribute(
-                    ast.Name(id="unit_syntax", ctx=ast.Load()),
-                    "Quantity",
-                    ctx=ast.Load(),
-                ),
+                ast.Name(id="_unit_syntax_q", ctx=ast.Load()),
                 args=[value, node.units],
                 keywords=[],
             )
@@ -38,13 +35,7 @@ def transform(code: str) -> str:
     """Transform a string of python-with-units into a standard python string"""
 
     tree = parse_string(code, mode="file")
-    ureg = pint.UnitRegistry()
+    ureg = pint._DEFAULT_REGISTRY
     tree_std = UnitExprTransformer(ureg).visit(tree)
     tree_std = ast.fix_missing_locations(tree_std)
     return ast.unparse(tree_std)
-
-
-def transform_lines(lines: list[str]) -> list[str]:
-    """IPython transforms provide a list of strings in the current cell, but to parse correctly we
-    need to parse them as a single string"""
-    return transform("".join(lines)).splitlines(keepends=True)

unit_syntax-0.2.1/unit_syntax/__init__.py

@@ -1,68 +0,0 @@
-import pint
-
-# Use the _DEFAULT_REGISTRY so we can interoperate with other pint-using libraries
-ureg = pint._DEFAULT_REGISTRY
-
-
-def Quantity(value, units):
-    if isinstance(value, ureg.Quantity):
-        return value.to(units)
-    else:
-        return ureg.Quantity(value, units)
-
-
-def enable_ipython(debug_transform=False):
-    """
-    debug_transform -- if True, log the input and output of each transform
-    """
-    import IPython
-    from .transform import transform_lines
-
-    ip = IPython.get_ipython()
-    if not hasattr(ip, "input_transformers_post"):
-        raise ImportError("Unsupported IPython version, version >=7 is required")
-
-    if debug_transform:
-        import logging
-
-        logging.basicConfig(level=logging.DEBUG, force=True)
-
-        def transform_lines_dbg(lines):
-            ret = transform_lines(lines)
-            logging.debug("unit_syntax: %s -> %s", "\n".join(lines), "\n".join(ret))
-            return ret
-
-        do_transform = transform_lines_dbg
-    else:
-        do_transform = transform_lines
-    ip.input_transformers_post.append(do_transform)
-
-    # Overide default formatters to use reduced units.  This lets us keep using the
-    # default registry for interop with other pint-using libraries, but gives more
-    # sensible output in the notebook.
-    def add_formatter(mime, display_fn_name):
-        fn = getattr(pint.Quantity, display_fn_name, None)
-        if fn is None:
-            return
-
-        def fmt_reduced(q, *args):
-            return fn(q.to_reduced_units(), *args)
-
-        formatter = ip.display_formatter.formatters[mime]
-        formatter.for_type(pint.Quantity, fmt_reduced)
-
-    add_formatter("text/markdown", "_repr_markdown_")
-    add_formatter("text/html", "_repr_html_")
-    add_formatter("text/plain", "_repr_pretty_")
-    add_formatter("text/latex", "_repr_latex_")
-
-    # ensure the module is still visible if imported via
-    # `from unit_syntax import ipython` for some reason
-    ip.run_cell("import unit_syntax")
-
-    try:
-        import matplotlib
-
-        pint.setup_matplotlib(True)
-    except ImportError:
-        pass

unit_syntax-0.2.1/unit_syntax/ipython/__init__.py

@@ -1,3 +0,0 @@
-from .. import enable_ipython
-
-enable_ipython()