Version 0.3

Author: jay3332

README.md

@@ -155,3 +155,16 @@ for boosts on both performance and precision.
 - Many functions now have positional-only arguments for slight performance boosts
     - This drops support for Python 3.7
 - Messages retrieved from `ParsingError.friendly` are now much more descriptive. 
+
+### v0.3
+
+#### What's new?
+- Unary plus is now supported (E.g. `+5`)
+- Scientific notation is now supported (E.g. `4E-2`)
+    - To reduce conflics, 'E' __must__ be captialized.   
+      This means that `2e9` would evaluate to `2 * e * 9`, for example.
+- The `cls` kwarg is now supported in `expr.evaluate`
+        
+#### Bug fixes
+- Catch `OverflowError` in the `expr.Overflow` parsing error.
+- Fix invalid typings with `Callable`

expr/__init__.py

@@ -8,5 +8,5 @@
 from .grammar import *
 from .parser import *
 
-__version__ = '0.2.2'
+__version__ = '0.3.0'
 __author__ = 'jay3332'

expr/core.py

@@ -1,6 +1,12 @@
-from typing import Optional, Tuple
+from decimal import Decimal
+from typing import Optional, Tuple, Type, TypeVar, Union
+
 from .parser import Parser
 
+
+C = TypeVar('C', bound=Union[float, Decimal])
+
+
 __all__: Tuple[str, ...] = (
     'evaluate',
     'create_state',
@@ -10,13 +16,13 @@
 state: Optional[Parser] = None
 
 
-def evaluate(expr: str, /, **kwargs) -> float:
+def evaluate(expr: str, /, *, cls: Type[C] = Decimal, **kwargs) -> C:
     global state
 
     if not state:
         state = Parser(**kwargs)
 
-    return state.evaluate(expr)
+    return state.evaluate(expr, cls=cls)
 
 
 def create_state(**kwargs) -> Parser:

expr/grammar.py

@@ -30,6 +30,7 @@ def add_ignores(self, /) -> None:
 
     def add_basic(self, /) -> None:
         self.add('NUMBER', r'([0-9]+(\.[0-9]*)?|\.[0-9]+)')
+        self.add('E', 'E')
         self.add('NAME', r'[a-zA-Z_][a-zA-Z0-9_]*')
         self.add('LPAREN', r'\(')
         self.add('RPAREN', r'\)')

expr/parser.py

@@ -86,25 +86,25 @@ def __new_init__(self, *args, **kwargs):
 # noinspection PyArgumentList,PyUnresolvedReferences
 class Parser(metaclass=ParserMeta):
     def __init__(
-            self,
-            /,
-            *,
-            max_safe_number: float = 9e9,
-            max_exponent: float = 128,
-            max_factorial: float = 64,
-            builtins: Dict[str, Callable[[DT], DT]] = None,
-            constants: Dict[str, DT] = None,
-            variables: Dict[str, DT] = None,
-            decimal_cls: Type[DT] = Decimal,
-            lexer_cls: Type[LGT] = LexerGenerator
+        self,
+        /,
+        *,
+        max_safe_number: float = 9e9,
+        max_exponent: float = 128,
+        max_factorial: float = 64,
+        builtins: Dict[str, Callable[[DT], DT]] = None,
+        constants: Dict[str, DT] = None,
+        variables: Dict[str, DT] = None,
+        decimal_cls: Type[DT] = Decimal,
+        lexer_cls: Type[LGT] = LexerGenerator
     ) -> None:
         if not issubclass(decimal_cls, Decimal):
             raise TypeError('decimal_cls must inherit from decimal.Decimal')
 
         _ = decimal_cls
-        self._max_safe_number: DT = _(max_safe_number)
-        self._max_exponent: DT = _(max_exponent)
-        self._max_factorial: DT = _(max_factorial)
+        self._max_safe_number: DT = _(max_safe_number) if max_safe_number is not None else _('inf')
+        self._max_exponent: DT = _(max_exponent) if max_exponent is not None else _('inf')
+        self._max_factorial: DT = _(max_factorial) if max_factorial is not None else _('inf')
 
         _builtins: Dict[str, Callable[[DT], DT]] = {
             'rad': lambda d: _(math.radians(float(d))),
@@ -155,9 +155,6 @@ def __init__(
 
         self._functions: Dict[str, Callable[[DT], DT]] = _builtins
 
-    def __repr__(self) -> str:
-        return f'<expr.{self.__class__.__name__}>'
-
     @rule('expr : NUMBER')
     def number(self, p: List[_Token], /) -> Number:
         number = Number(p[0].getstr())
@@ -208,6 +205,10 @@ def operator(self, p: List[_Token], /) -> Any:
     def uminus(self, p: List[_Token], /) -> Any:
         return Number(-(p[1].eval()))
 
+    @rule("expr : ADD expr", precedence='UMINUS')
+    def upos(self, p: List[_Token], /) -> Any:
+        return p[1]
+
     @rule('expr : NAME EQ expr')
     def declare(self, p: List[_Token], /) -> Any:
         _name = p[0].getstr()
@@ -223,6 +224,10 @@ def function(self, p: List[_Token], /) -> Any:
 
         return Mul(self.getvar(p[0]), p[2])  # Probably this instead
 
+    @rule("expr : expr E expr", precedence='POW')
+    def scinot_e(self, p: List[_Token], /) -> Any:
+        return Mul(p[0], Pow(Number(10), p[2]))
+
     @rule('expr : NAME')
     def getvar(self, p: List[_Token], /) -> Any:
         name = p[0].getstr()
@@ -248,6 +253,9 @@ def _build_lexer(self, /) -> Lexer:
         self.__lexer__ = res = self.__lexer_generator__.build()
         return res
 
+    def __repr__(self, /) -> str:
+        return f'<expr.{self.__class__.__name__} object at {id(self):x}>'
+
     def __call__(self, expr: str, /, *, cls: Type[OT] = Decimal) -> Optional[OT]:
         return self.evaluate(expr, cls=cls)
 
@@ -265,6 +273,9 @@ def evaluate(self, expr: str, /, *, cls: Type[OT] = Decimal) -> Optional[OT]:
         except (ZeroDivisionError, _ZeroDivision):
             raise DivisionByZero()
 
+        except (ValueError, OverflowError):
+            raise Overflow()
+
         except InvalidOperation as exc:
             if isinstance(exc.args[0][0], DivisionUndefined):
                 raise DivisionByZero()

setup.py

@@ -3,17 +3,19 @@
 
 
 with open('expr/__init__.py') as f:
+    r = f.read()
+
     try:
         version = re.search(
-            r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', f.read(), re.M
+            r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', r, re.M
         ).group(1)
     except AttributeError:
         raise RuntimeError('Could not identify version') from None
 
     # look at this boilerplate code
     try:
         author = re.search(
-            r'^__author__\s*=\s*[\'"]([^\'"]*)[\'"]', f.read(), re.M
+            r'^__author__\s*=\s*[\'"]([^\'"]*)[\'"]', r, re.M
         ).group(1)
     except AttributeError:
         author = 'jay3332'