simpleeval 0.9.12__tar.gz → 1.0.0__tar.gz

{simpleeval-0.9.12 → simpleeval-1.0.0}/.gitignore

@@ -3,6 +3,7 @@ build
 dist
 MANIFEST
 .idea
+.vscode
 venv
 .eggs/
 .coverage

{simpleeval-0.9.12 → simpleeval-1.0.0}/LICENCE

@@ -1,4 +1,4 @@
-simpleeval - Copyright (c) 2013-2017 Daniel Fairhead
+simpleeval - Copyright (c) 2013-2024 Daniel Fairhead
 
 (MIT Licence)
 

{simpleeval-0.9.12 → simpleeval-1.0.0}/Makefile

@@ -1,5 +1,5 @@
 test:
-	python test_simpleeval.py
+	python -Werror test_simpleeval.py
 
 autotest:
 	find . -name \*.py -not -path .\/.v\* | entr make test
@@ -22,9 +22,10 @@ coverage:
 	coverage run test_simpleeval.py
 
 lint:
-	black --check --diff simpleeval.py test_simpleeval.py
-	isort --check-only --diff simpleeval.py test_simpleeval.py
+	ruff check simpleeval.py test_simpleeval.py
+	ruff format --check simpleeval.py test_simpleeval.py
+	mypy simpleeval.py test_simpleeval.py
 
 format:
-	black simpleeval.py test_simpleeval.py
-	isort simpleeval.py	test_simpleeval.py
+	ruff check --fix-only simpleeval.py test_simpleeval.py
+	ruff format simpleeval.py test_simpleeval.py

{simpleeval-0.9.12 → simpleeval-1.0.0}/PKG-INFO

@@ -1,37 +1,49 @@
 Metadata-Version: 2.1
 Name: simpleeval
-Version: 0.9.12
+Version: 1.0.0
 Summary: A simple, safe single expression evaluator library.
 Home-page: https://github.com/danthedeckie/simpleeval
 Author: Daniel Fairhead
 Author-email: danthedeckie@gmail.com
-License: UNKNOWN
+License: MIT
 Keywords: eval,simple,expression,parse,ast
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Programming Language :: Python
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENCE
 
 simpleeval (Simple Eval)
 ========================
 
-.. image:: https://github.com/danthedeckie/simpleeval/actions/workflows/ci.yml/badge.svg?branch=gh-actions-build
+.. |build-status| image:: https://github.com/danthedeckie/simpleeval/actions/workflows/ci.yml/badge.svg?branch=gh-actions-build
    :target: https://github.com/danthedeckie/simpleeval/actions/
    :alt: Build Status
 
-.. image:: https://codecov.io/gh/danthedeckie/simpleeval/branch/master/graph/badge.svg?token=isRnN1yrca
+.. |code-coverage| image:: https://codecov.io/gh/danthedeckie/simpleeval/branch/master/graph/badge.svg?token=isRnN1yrca
    :target: https://codecov.io/gh/danthedeckie/simpleeval
-   :alt: Code Coverage
+   :alt: Code Coverage Status
 
-.. image:: https://badge.fury.io/py/simpleeval.svg
+.. |pypi-version| image:: https://badge.fury.io/py/simpleeval.svg
    :target: https://badge.fury.io/py/simpleeval
    :alt: PyPI Version
 
-A quick single file library for easily adding evaluatable expressions into
+.. |python-versions| image:: https://img.shields.io/badge/python-3.9_%7C_3.10_%7C_3.11_%7C_3.12_%7C_3.13_%7C_PyPy3.9_%7C_PyPy3.10-blue
+   :alt: Static Badge
+
+.. |pypi-monthly-downloads| image:: https://img.shields.io/pypi/dm/SimpleEval
+   :alt: PyPI - Downloads
+
+.. |formatting-with-ruff| image:: https://img.shields.io/badge/-ruff-black?logo=lightning&logoColor=%2300ff00&link=https%3A%2F%2Fdocs.astral.sh%2Fruff%2F
+   :alt: Static Badge
+
+|build-status| |code-coverage| |pypi-version| |python-versions| |pypi-monthly-downloads| |formatting-with-ruff|
+
+
+A single file library for easily adding evaluatable expressions into
 python projects.  Say you want to allow a user to set an alarm volume, which
 could depend on the time of day, alarm level, how many previous alarms had gone
 off, and if there is music playing at the time.
@@ -39,8 +51,9 @@ off, and if there is music playing at the time.
 Or if you want to allow simple formulae in a web application, but don't want to
 give full eval() access, or don't want to run in javascript on the client side.
 
-It's deliberately very simple, pull it in from PyPI (pip or easy_install), or
-even just a single file you can dump into a project.
+It's deliberately trying to stay simple to use and not have millions of features,
+pull it in from PyPI (pip or easy_install), or even just a single file you can dump
+into a project.
 
 Internally, it's using the amazing python ``ast`` module to parse the
 expression, which allows very fine control of what is and isn't allowed.  It
@@ -55,7 +68,7 @@ Operators_ section below)
 
 You should be aware of this when deploying in a public setting.
 
-The defaults are pretty locked down and basic, and it's very easy to add
+The defaults are pretty locked down and basic, and it's easy to add
 whatever extra specific functionality you need (your own functions,
 variable/name lookup, etc).
 
@@ -149,23 +162,36 @@ the defaults:
 |        | ``"spam" in "my breakfast"``       |
 |        | -> ``False``                       |
 +--------+------------------------------------+
+| ``^``  | "bitwise exclusive OR" (xor)       |
+|        | ``62 ^ 20`` -> ``42``              |
++--------+------------------------------------+
+| ``|``  | "bitwise OR"                       |
+|        | ``8 | 34`` -> ``42``               |
++--------+------------------------------------+
+| ``&``  | "bitwise AND"                      |
+|        | ``100 & 63`` -> ``36``             |
++--------+------------------------------------+
+| ``~``  | "bitwise invert"                   |
+|        | ``~ -43`` -> ``42``                |
++--------+------------------------------------+
 
 
-The ``^`` operator is notably missing - not because it's hard, but because it
-is often mistaken for a exponent operator, not the bitwise operation that it is
-in python.  It's trivial to add back in again if you wish (using the class
-based evaluator explained below):
+The ``^`` operator is often mistaken for a exponent operator, not the bitwise 
+operation that it is in python, so if you want ``3 ^ 2`` to equal ``9``, you can
+replace the operator like this:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> import ast
-    >>> import operator
+    >>> from simpleeval import safe_power
 
     >>> s = SimpleEval()
-    >>> s.operators[ast.BitXor] = operator.xor
+    >>> s.operators[ast.BitXor] = safe_power
 
-    >>> s.eval("2 ^ 10")
-    8
+    >>> s.eval("3 ^ 2")
+    9
+
+for example.
 
 Limited Power
 ~~~~~~~~~~~~~
@@ -173,13 +199,13 @@ Limited Power
 Also note, the ``**`` operator has been locked down by default to have a
 maximum input value of ``4000000``, which makes it somewhat harder to make
 expressions which go on for ever.  You can change this limit by changing the
-``simpleeval.POWER_MAX`` module level value to whatever is an appropriate value
+``simpleeval.MAX_POWER`` module level value to whatever is an appropriate value
 for you (and the hardware that you're running on) or if you want to completely
 remove all limitations, you can set the ``s.operators[ast.Pow] = operator.pow``
 or make your own function.
 
 On my computer, ``9**9**5`` evaluates almost instantly, but ``9**9**6`` takes
-over 30 seconds.  Since ``9**7`` is ``4782969``, and so over the ``POWER_MAX``
+over 30 seconds.  Since ``9**7`` is ``4782969``, and so over the ``MAX_POWER``
 limit, it throws a ``NumberTooHigh`` exception for you. (Otherwise it would go
 on for hours, or until the computer runs out of memory)
 
@@ -197,7 +223,7 @@ If Expressions
 
 You can use python style ``if x then y else z`` type expressions:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("'equal' if x == y else 'not equal'",
                     names={"x": 1, "y": 2})
@@ -205,7 +231,7 @@ You can use python style ``if x then y else z`` type expressions:
 
 which, of course, can be nested:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("'a' if 1 == 2 else 'b' if 2 == 3 else 'c'")
     'c'
@@ -216,7 +242,7 @@ Functions
 
 You can define functions which you'd like the expresssions to have access to:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("double(21)", functions={"double": lambda x:x*2})
     42
@@ -224,7 +250,7 @@ You can define functions which you'd like the expresssions to have access to:
 You can define "real" functions to pass in rather than lambdas, of course too,
 and even re-name them so that expressions can be shorter
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> def double(x):
             return x * 2
@@ -243,13 +269,13 @@ are provided in the ``DEFAULT_FUNCTIONS`` dict:
 +----------------+--------------------------------------------------+
 | ``float(x)``   | Convert ``x`` to a ``float``.                    |
 +----------------+--------------------------------------------------+
-| ``str(x)``     | Convert ``x`` to a ``str`` (``unicode`` in py2)  |
+| ``str(x)``     | Convert ``x`` to a ``str``                       |
 +----------------+--------------------------------------------------+
 
 If you want to provide a list of functions, but want to keep these as well,
 then you can do a normal python ``.copy()`` & ``.update``:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> my_functions = simpleeval.DEFAULT_FUNCTIONS.copy()
     >>> my_functions.update(
@@ -264,7 +290,7 @@ Names
 Sometimes it's useful to have variables available, which in python terminology
 are called 'names'.
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("a + b", names={"a": 11, "b": 100})
     111
@@ -272,7 +298,7 @@ are called 'names'.
 You can also hand the handling of names over to a function, if you prefer:
 
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> def name_handler(node):
             return ord(node.id[0].lower(a))-96
@@ -281,9 +307,34 @@ You can also hand the handling of names over to a function, if you prefer:
     3
 
 That was a bit of a silly example, but you could use this for pulling values
-from a database or file, say, or doing some kind of caching system.
+from a database or file, looking up spreadsheet cells, say, or doing some kind of caching system.
+
+In general, when it attempts to find a variable by name, if it cannot find one,
+then it will look in the ``functions`` for a function of that name.  If you want your name handler
+function to return an "I can't find that name!", then it should raise a ``simpleeval.NameNotDefined`` 
+exception. Eg:
+
+.. code-block:: pycon
 
-The two default names that are provided are ``True`` and ``False``.  So if you want to provide your own names, but want ``True`` and ``False`` to keep working, either provide them yourself, or ``.copy()`` and ``.update`` the ``DEFAULT_NAMES``. (See functions example above).
+   >>> def name_handler(node):
+   ...     if node.id[0] == 'a':
+   ...         return 21
+   ...     raise NameNotDefined(node.id[0], "Not found")
+   ...
+   ... simple_eval('a + a', names=name_handler, functions={"b": 100})
+
+   42
+
+   >>> simple_eval('a + b', names=name_handler, functions={'b': 100})
+   121
+
+(Note: in that example, putting a number directly into the ``functions`` dict was done just to
+show the fall-back to functions.  Normally only put actual callables in there.)
+
+
+The two default names that are provided are ``True`` and ``False``.  So if you want to provide
+your own names, but want ``True`` and ``False`` to keep working, either provide them yourself,
+or ``.copy()`` and ``.update`` the ``DEFAULT_NAMES``. (See functions example above).
 
 Creating an Evaluator Class
 ---------------------------
@@ -293,7 +344,7 @@ evaluations, you can create a SimpleEval object, and pass it expressions each
 time (which should be a bit quicker, and certainly more convenient for some use
 cases):
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> s = SimpleEval()
 
@@ -305,6 +356,22 @@ cases):
 
     # and so on...
 
+One useful feature of using the ``SimpleEval`` object is that you can parse an expression
+once, and then evaluate it mulitple times using different ``names``:
+
+.. code-block:: python
+
+    # Set up & Cache the parse tree:
+    expression = "foo + bar"
+    parsed = s.parse(expression)
+
+    # evaluate the expression multiple times:
+    for names in [{"foo": 1, "bar": 10}, {"foo": 100, "bar": 42}]:
+        s.names = names
+        print(s.eval(expression, previously_parsed=parsed))
+
+for instance.  This may help with performance.
+
 You can assign / edit the various options of the ``SimpleEval`` object if you
 want to.  Either assign them during creation (like the ``simple_eval``
 function)
@@ -356,7 +423,7 @@ comprehensions.
 Since the primary intention of this library is short expressions - an extra 'sweetener' is
 enabled by default.  You can access a dict (or similar's) keys using the .attr syntax:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>>  simple_eval("foo.bar", names={"foo": {"bar": 42}})
     42
@@ -386,8 +453,7 @@ and then use ``EvalNoMethods`` instead of the ``SimpleEval`` class.
 Other...
 --------
 
-The library supports python 3 - but should be mostly compatible (and tested before 0.9.11)
-with python 2.7 as well.
+The library supports Python 3.9 and higher.
 
 Object attributes that start with ``_`` or ``func_`` are disallowed by default.
 If you really need that (BE CAREFUL!), then modify the module global
@@ -418,11 +484,18 @@ Or to set the tests running on every file change:
 
 (requires ``entr``) 
 
+I'm trying to keep the codebase relatively clean with Black, isort, pylint & mypy.
+See::
+
+    $ make format
+
+and::
+
+    $ make lint
+
 BEWARE
 ------
 
-I've done the best I can with this library - but there's no warrenty, no guarentee, nada.  A lot of
+I've done the best I can with this library - but there's no warranty, no guarantee, nada.  A lot of
 very clever people think the whole idea of trying to sandbox CPython is impossible.  Read the code
 yourself, and use it at your own risk.
-
-

{simpleeval-0.9.12 → simpleeval-1.0.0}/README.rst

@@ -1,19 +1,31 @@
 simpleeval (Simple Eval)
 ========================
 
-.. image:: https://github.com/danthedeckie/simpleeval/actions/workflows/ci.yml/badge.svg?branch=gh-actions-build
+.. |build-status| image:: https://github.com/danthedeckie/simpleeval/actions/workflows/ci.yml/badge.svg?branch=gh-actions-build
    :target: https://github.com/danthedeckie/simpleeval/actions/
    :alt: Build Status
 
-.. image:: https://codecov.io/gh/danthedeckie/simpleeval/branch/master/graph/badge.svg?token=isRnN1yrca
+.. |code-coverage| image:: https://codecov.io/gh/danthedeckie/simpleeval/branch/master/graph/badge.svg?token=isRnN1yrca
    :target: https://codecov.io/gh/danthedeckie/simpleeval
-   :alt: Code Coverage
+   :alt: Code Coverage Status
 
-.. image:: https://badge.fury.io/py/simpleeval.svg
+.. |pypi-version| image:: https://badge.fury.io/py/simpleeval.svg
    :target: https://badge.fury.io/py/simpleeval
    :alt: PyPI Version
 
-A quick single file library for easily adding evaluatable expressions into
+.. |python-versions| image:: https://img.shields.io/badge/python-3.9_%7C_3.10_%7C_3.11_%7C_3.12_%7C_3.13_%7C_PyPy3.9_%7C_PyPy3.10-blue
+   :alt: Static Badge
+
+.. |pypi-monthly-downloads| image:: https://img.shields.io/pypi/dm/SimpleEval
+   :alt: PyPI - Downloads
+
+.. |formatting-with-ruff| image:: https://img.shields.io/badge/-ruff-black?logo=lightning&logoColor=%2300ff00&link=https%3A%2F%2Fdocs.astral.sh%2Fruff%2F
+   :alt: Static Badge
+
+|build-status| |code-coverage| |pypi-version| |python-versions| |pypi-monthly-downloads| |formatting-with-ruff|
+
+
+A single file library for easily adding evaluatable expressions into
 python projects.  Say you want to allow a user to set an alarm volume, which
 could depend on the time of day, alarm level, how many previous alarms had gone
 off, and if there is music playing at the time.
@@ -21,8 +33,9 @@ off, and if there is music playing at the time.
 Or if you want to allow simple formulae in a web application, but don't want to
 give full eval() access, or don't want to run in javascript on the client side.
 
-It's deliberately very simple, pull it in from PyPI (pip or easy_install), or
-even just a single file you can dump into a project.
+It's deliberately trying to stay simple to use and not have millions of features,
+pull it in from PyPI (pip or easy_install), or even just a single file you can dump
+into a project.
 
 Internally, it's using the amazing python ``ast`` module to parse the
 expression, which allows very fine control of what is and isn't allowed.  It
@@ -37,7 +50,7 @@ Operators_ section below)
 
 You should be aware of this when deploying in a public setting.
 
-The defaults are pretty locked down and basic, and it's very easy to add
+The defaults are pretty locked down and basic, and it's easy to add
 whatever extra specific functionality you need (your own functions,
 variable/name lookup, etc).
 
@@ -131,23 +144,36 @@ the defaults:
 |        | ``"spam" in "my breakfast"``       |
 |        | -> ``False``                       |
 +--------+------------------------------------+
+| ``^``  | "bitwise exclusive OR" (xor)       |
+|        | ``62 ^ 20`` -> ``42``              |
++--------+------------------------------------+
+| ``|``  | "bitwise OR"                       |
+|        | ``8 | 34`` -> ``42``               |
++--------+------------------------------------+
+| ``&``  | "bitwise AND"                      |
+|        | ``100 & 63`` -> ``36``             |
++--------+------------------------------------+
+| ``~``  | "bitwise invert"                   |
+|        | ``~ -43`` -> ``42``                |
++--------+------------------------------------+
 
 
-The ``^`` operator is notably missing - not because it's hard, but because it
-is often mistaken for a exponent operator, not the bitwise operation that it is
-in python.  It's trivial to add back in again if you wish (using the class
-based evaluator explained below):
+The ``^`` operator is often mistaken for a exponent operator, not the bitwise 
+operation that it is in python, so if you want ``3 ^ 2`` to equal ``9``, you can
+replace the operator like this:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> import ast
-    >>> import operator
+    >>> from simpleeval import safe_power
 
     >>> s = SimpleEval()
-    >>> s.operators[ast.BitXor] = operator.xor
+    >>> s.operators[ast.BitXor] = safe_power
 
-    >>> s.eval("2 ^ 10")
-    8
+    >>> s.eval("3 ^ 2")
+    9
+
+for example.
 
 Limited Power
 ~~~~~~~~~~~~~
@@ -155,13 +181,13 @@ Limited Power
 Also note, the ``**`` operator has been locked down by default to have a
 maximum input value of ``4000000``, which makes it somewhat harder to make
 expressions which go on for ever.  You can change this limit by changing the
-``simpleeval.POWER_MAX`` module level value to whatever is an appropriate value
+``simpleeval.MAX_POWER`` module level value to whatever is an appropriate value
 for you (and the hardware that you're running on) or if you want to completely
 remove all limitations, you can set the ``s.operators[ast.Pow] = operator.pow``
 or make your own function.
 
 On my computer, ``9**9**5`` evaluates almost instantly, but ``9**9**6`` takes
-over 30 seconds.  Since ``9**7`` is ``4782969``, and so over the ``POWER_MAX``
+over 30 seconds.  Since ``9**7`` is ``4782969``, and so over the ``MAX_POWER``
 limit, it throws a ``NumberTooHigh`` exception for you. (Otherwise it would go
 on for hours, or until the computer runs out of memory)
 
@@ -179,7 +205,7 @@ If Expressions
 
 You can use python style ``if x then y else z`` type expressions:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("'equal' if x == y else 'not equal'",
                     names={"x": 1, "y": 2})
@@ -187,7 +213,7 @@ You can use python style ``if x then y else z`` type expressions:
 
 which, of course, can be nested:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("'a' if 1 == 2 else 'b' if 2 == 3 else 'c'")
     'c'
@@ -198,7 +224,7 @@ Functions
 
 You can define functions which you'd like the expresssions to have access to:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("double(21)", functions={"double": lambda x:x*2})
     42
@@ -206,7 +232,7 @@ You can define functions which you'd like the expresssions to have access to:
 You can define "real" functions to pass in rather than lambdas, of course too,
 and even re-name them so that expressions can be shorter
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> def double(x):
             return x * 2
@@ -225,13 +251,13 @@ are provided in the ``DEFAULT_FUNCTIONS`` dict:
 +----------------+--------------------------------------------------+
 | ``float(x)``   | Convert ``x`` to a ``float``.                    |
 +----------------+--------------------------------------------------+
-| ``str(x)``     | Convert ``x`` to a ``str`` (``unicode`` in py2)  |
+| ``str(x)``     | Convert ``x`` to a ``str``                       |
 +----------------+--------------------------------------------------+
 
 If you want to provide a list of functions, but want to keep these as well,
 then you can do a normal python ``.copy()`` & ``.update``:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> my_functions = simpleeval.DEFAULT_FUNCTIONS.copy()
     >>> my_functions.update(
@@ -246,7 +272,7 @@ Names
 Sometimes it's useful to have variables available, which in python terminology
 are called 'names'.
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> simple_eval("a + b", names={"a": 11, "b": 100})
     111
@@ -254,7 +280,7 @@ are called 'names'.
 You can also hand the handling of names over to a function, if you prefer:
 
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> def name_handler(node):
             return ord(node.id[0].lower(a))-96
@@ -263,9 +289,34 @@ You can also hand the handling of names over to a function, if you prefer:
     3
 
 That was a bit of a silly example, but you could use this for pulling values
-from a database or file, say, or doing some kind of caching system.
+from a database or file, looking up spreadsheet cells, say, or doing some kind of caching system.
+
+In general, when it attempts to find a variable by name, if it cannot find one,
+then it will look in the ``functions`` for a function of that name.  If you want your name handler
+function to return an "I can't find that name!", then it should raise a ``simpleeval.NameNotDefined`` 
+exception. Eg:
 
-The two default names that are provided are ``True`` and ``False``.  So if you want to provide your own names, but want ``True`` and ``False`` to keep working, either provide them yourself, or ``.copy()`` and ``.update`` the ``DEFAULT_NAMES``. (See functions example above).
+.. code-block:: pycon
+
+   >>> def name_handler(node):
+   ...     if node.id[0] == 'a':
+   ...         return 21
+   ...     raise NameNotDefined(node.id[0], "Not found")
+   ...
+   ... simple_eval('a + a', names=name_handler, functions={"b": 100})
+
+   42
+
+   >>> simple_eval('a + b', names=name_handler, functions={'b': 100})
+   121
+
+(Note: in that example, putting a number directly into the ``functions`` dict was done just to
+show the fall-back to functions.  Normally only put actual callables in there.)
+
+
+The two default names that are provided are ``True`` and ``False``.  So if you want to provide
+your own names, but want ``True`` and ``False`` to keep working, either provide them yourself,
+or ``.copy()`` and ``.update`` the ``DEFAULT_NAMES``. (See functions example above).
 
 Creating an Evaluator Class
 ---------------------------
@@ -275,7 +326,7 @@ evaluations, you can create a SimpleEval object, and pass it expressions each
 time (which should be a bit quicker, and certainly more convenient for some use
 cases):
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>> s = SimpleEval()
 
@@ -287,6 +338,22 @@ cases):
 
     # and so on...
 
+One useful feature of using the ``SimpleEval`` object is that you can parse an expression
+once, and then evaluate it mulitple times using different ``names``:
+
+.. code-block:: python
+
+    # Set up & Cache the parse tree:
+    expression = "foo + bar"
+    parsed = s.parse(expression)
+
+    # evaluate the expression multiple times:
+    for names in [{"foo": 1, "bar": 10}, {"foo": 100, "bar": 42}]:
+        s.names = names
+        print(s.eval(expression, previously_parsed=parsed))
+
+for instance.  This may help with performance.
+
 You can assign / edit the various options of the ``SimpleEval`` object if you
 want to.  Either assign them during creation (like the ``simple_eval``
 function)
@@ -338,7 +405,7 @@ comprehensions.
 Since the primary intention of this library is short expressions - an extra 'sweetener' is
 enabled by default.  You can access a dict (or similar's) keys using the .attr syntax:
 
-.. code-block:: python
+.. code-block:: pycon
 
     >>>  simple_eval("foo.bar", names={"foo": {"bar": 42}})
     42
@@ -368,8 +435,7 @@ and then use ``EvalNoMethods`` instead of the ``SimpleEval`` class.
 Other...
 --------
 
-The library supports python 3 - but should be mostly compatible (and tested before 0.9.11)
-with python 2.7 as well.
+The library supports Python 3.9 and higher.
 
 Object attributes that start with ``_`` or ``func_`` are disallowed by default.
 If you really need that (BE CAREFUL!), then modify the module global
@@ -400,9 +466,18 @@ Or to set the tests running on every file change:
 
 (requires ``entr``) 
 
+I'm trying to keep the codebase relatively clean with Black, isort, pylint & mypy.
+See::
+
+    $ make format
+
+and::
+
+    $ make lint
+
 BEWARE
 ------
 
-I've done the best I can with this library - but there's no warrenty, no guarentee, nada.  A lot of
+I've done the best I can with this library - but there's no warranty, no guarantee, nada.  A lot of
 very clever people think the whole idea of trying to sandbox CPython is impossible.  Read the code
 yourself, and use it at your own risk.

{simpleeval-0.9.12 → simpleeval-1.0.0}/pyproject.toml

@@ -1,11 +1,14 @@
 [build-system]
-requires = ["setuptools>=30.3.0", "wheel", "build"]
+requires = ["setuptools>=30.3.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.black]
 line-length = 99
 target-version = ['py310']
 
+[tool.ruff]
+line-length = 99
+
 [tool.isort]
 combine_as_imports = true
 float_to_top = true
@@ -16,7 +19,9 @@ multi_line_output = 3
 
 [tool.pylint.messages_control]
 disable = [
+    "fixme",
     "consider-using-f-string",
+    "raise-missing-from",
     "invalid-name",
     "too-few-public-methods",
     "too-many-public-methods",