From 820358c1d5586065c7bf7308235074eff1157d41 Mon Sep 17 00:00:00 2001 From: root Date: Tue, 11 Jul 2023 06:23:59 +0000 Subject: [PATCH] add spec and rpm --- pure_eval-0.2.2.tar.gz | Bin 0 -> 19395 bytes python-pure-eval.spec | 693 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 693 insertions(+) create mode 100644 pure_eval-0.2.2.tar.gz create mode 100644 python-pure-eval.spec diff --git a/pure_eval-0.2.2.tar.gz b/pure_eval-0.2.2.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1aa6780903b0a5c1f7f27a49fa132bf701e5d0f7 GIT binary patch literal 19395 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 +``` + +OK, but you could have done the same thing with `eval`. The useful part is that it will refuse to evaluate the property `rect.area` because that would trigger unknown code. If we try, it'll raise a `CannotEval` exception. + +```python +from pure_eval import CannotEval + +try: + print("rect.area:", evaluator[the_tuple.elts[2]]) # fails +except CannotEval as e: + print(e) # prints CannotEval +``` + +To find all the expressions that can be evaluated in a tree: + +```python +for node, value in evaluator.find_expressions(tree): + print(ast.dump(node), value) +``` + +Output: + +```python +Attribute(value=Name(id='rect', ctx=Load()), attr='width', ctx=Load()) 3 +Attribute(value=Name(id='rect', ctx=Load()), attr='height', ctx=Load()) 5 +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +``` + +Note that this includes `rect` three times, once for each appearance in the source code. Since all these nodes are equivalent, we can group them together: + +```python +from pure_eval import group_expressions + +for nodes, values in group_expressions(evaluator.find_expressions(tree)): + print(len(nodes), "nodes with value:", values) +``` + +Output: + +``` +1 nodes with value: 3 +1 nodes with value: 5 +3 nodes with value: <__main__.Rectangle object at 0x10d374d30> +``` + +If we want to list all the expressions in a tree, we may want to filter out certain expressions whose values are obvious. For example, suppose we have a function `foo`: + +```python +def foo(): + pass +``` + +If we refer to `foo` by its name as usual, then that's not interesting: + +```python +from pure_eval import is_expression_interesting + +node = ast.parse('foo').body[0].value +print(ast.dump(node)) +print(is_expression_interesting(node, foo)) +``` + +Output: + +```python +Name(id='foo', ctx=Load()) +False +``` + +But if we refer to it by a different name, then it's interesting: + +```python +node = ast.parse('bar').body[0].value +print(ast.dump(node)) +print(is_expression_interesting(node, foo)) +``` + +Output: + +```python +Name(id='bar', ctx=Load()) +True +``` + +In general `is_expression_interesting` returns False for the following values: +- Literals (e.g. `123`, `'abc'`, `[1, 2, 3]`, `{'a': (), 'b': ([1, 2], [3])}`) +- Variables or attributes whose name is equal to the value's `__name__`, such as `foo` above or `self.foo` if it was a method. +- Builtins (e.g. `len`) referred to by their usual name. + +To make things easier, you can combine finding expressions, grouping them, and filtering out the obvious ones with: + +```python +evaluator.interesting_expressions_grouped(root) +``` + +To get the source code of an AST node, I recommend [asttokens](https://github.com/gristlabs/asttokens). + +Here's a complete example that brings it all together: + +```python +from asttokens import ASTTokens +from pure_eval import Evaluator + +source = """ +x = 1 +d = {x: 2} +y = d[x] +""" + +names = {} +exec(source, names) +atok = ASTTokens(source, parse=True) +for nodes, value in Evaluator(names).interesting_expressions_grouped(atok.tree): + print(atok.get_text(nodes[0]), "=", value) +``` + +Output: + +```python +x = 1 +d = {1: 2} +y = 2 +d[x] = 2 +``` + + + + +%package -n python3-pure-eval +Summary: Safely evaluate AST nodes without side effects +Provides: python-pure-eval +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +BuildRequires: python3-setuptools_scm +BuildRequires: python3-toml +%description -n python3-pure-eval +# `pure_eval` + +[![Build Status](https://travis-ci.org/alexmojaki/pure_eval.svg?branch=master)](https://travis-ci.org/alexmojaki/pure_eval) [![Coverage Status](https://coveralls.io/repos/github/alexmojaki/pure_eval/badge.svg?branch=master)](https://coveralls.io/github/alexmojaki/pure_eval?branch=master) [![Supports Python versions 3.5+](https://img.shields.io/pypi/pyversions/pure_eval.svg)](https://pypi.python.org/pypi/pure_eval) + +This is a Python package that lets you safely evaluate certain AST nodes without triggering arbitrary code that may have unwanted side effects. + +It can be installed from PyPI: + + pip install pure_eval + +To demonstrate usage, suppose we have an object defined as follows: + +```python +class Rectangle: + def __init__(self, width, height): + self.width = width + self.height = height + + @property + def area(self): + print("Calculating area...") + return self.width * self.height + + +rect = Rectangle(3, 5) +``` + +Given the `rect` object, we want to evaluate whatever expressions we can in this source code: + +```python +source = "(rect.width, rect.height, rect.area)" +``` + +This library works with the AST, so let's parse the source code and peek inside: + +```python +import ast + +tree = ast.parse(source) +the_tuple = tree.body[0].value +for node in the_tuple.elts: + print(ast.dump(node)) +``` + +Output: + +```python +Attribute(value=Name(id='rect', ctx=Load()), attr='width', ctx=Load()) +Attribute(value=Name(id='rect', ctx=Load()), attr='height', ctx=Load()) +Attribute(value=Name(id='rect', ctx=Load()), attr='area', ctx=Load()) +``` + +Now to actually use the library. First construct an Evaluator: + +```python +from pure_eval import Evaluator + +evaluator = Evaluator({"rect": rect}) +``` + +The argument to `Evaluator` should be a mapping from variable names to their values. Or if you have access to the stack frame where `rect` is defined, you can instead use: + +```python +evaluator = Evaluator.from_frame(frame) +``` + +Now to evaluate some nodes, using `evaluator[node]`: + +```python +print("rect.width:", evaluator[the_tuple.elts[0]]) +print("rect:", evaluator[the_tuple.elts[0].value]) +``` + +Output: + +``` +rect.width: 3 +rect: <__main__.Rectangle object at 0x105b0dd30> +``` + +OK, but you could have done the same thing with `eval`. The useful part is that it will refuse to evaluate the property `rect.area` because that would trigger unknown code. If we try, it'll raise a `CannotEval` exception. + +```python +from pure_eval import CannotEval + +try: + print("rect.area:", evaluator[the_tuple.elts[2]]) # fails +except CannotEval as e: + print(e) # prints CannotEval +``` + +To find all the expressions that can be evaluated in a tree: + +```python +for node, value in evaluator.find_expressions(tree): + print(ast.dump(node), value) +``` + +Output: + +```python +Attribute(value=Name(id='rect', ctx=Load()), attr='width', ctx=Load()) 3 +Attribute(value=Name(id='rect', ctx=Load()), attr='height', ctx=Load()) 5 +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +``` + +Note that this includes `rect` three times, once for each appearance in the source code. Since all these nodes are equivalent, we can group them together: + +```python +from pure_eval import group_expressions + +for nodes, values in group_expressions(evaluator.find_expressions(tree)): + print(len(nodes), "nodes with value:", values) +``` + +Output: + +``` +1 nodes with value: 3 +1 nodes with value: 5 +3 nodes with value: <__main__.Rectangle object at 0x10d374d30> +``` + +If we want to list all the expressions in a tree, we may want to filter out certain expressions whose values are obvious. For example, suppose we have a function `foo`: + +```python +def foo(): + pass +``` + +If we refer to `foo` by its name as usual, then that's not interesting: + +```python +from pure_eval import is_expression_interesting + +node = ast.parse('foo').body[0].value +print(ast.dump(node)) +print(is_expression_interesting(node, foo)) +``` + +Output: + +```python +Name(id='foo', ctx=Load()) +False +``` + +But if we refer to it by a different name, then it's interesting: + +```python +node = ast.parse('bar').body[0].value +print(ast.dump(node)) +print(is_expression_interesting(node, foo)) +``` + +Output: + +```python +Name(id='bar', ctx=Load()) +True +``` + +In general `is_expression_interesting` returns False for the following values: +- Literals (e.g. `123`, `'abc'`, `[1, 2, 3]`, `{'a': (), 'b': ([1, 2], [3])}`) +- Variables or attributes whose name is equal to the value's `__name__`, such as `foo` above or `self.foo` if it was a method. +- Builtins (e.g. `len`) referred to by their usual name. + +To make things easier, you can combine finding expressions, grouping them, and filtering out the obvious ones with: + +```python +evaluator.interesting_expressions_grouped(root) +``` + +To get the source code of an AST node, I recommend [asttokens](https://github.com/gristlabs/asttokens). + +Here's a complete example that brings it all together: + +```python +from asttokens import ASTTokens +from pure_eval import Evaluator + +source = """ +x = 1 +d = {x: 2} +y = d[x] +""" + +names = {} +exec(source, names) +atok = ASTTokens(source, parse=True) +for nodes, value in Evaluator(names).interesting_expressions_grouped(atok.tree): + print(atok.get_text(nodes[0]), "=", value) +``` + +Output: + +```python +x = 1 +d = {1: 2} +y = 2 +d[x] = 2 +``` + + + + +%package help +Summary: Development documents and examples for pure-eval +Provides: python3-pure-eval-doc +%description help +# `pure_eval` + +[![Build Status](https://travis-ci.org/alexmojaki/pure_eval.svg?branch=master)](https://travis-ci.org/alexmojaki/pure_eval) [![Coverage Status](https://coveralls.io/repos/github/alexmojaki/pure_eval/badge.svg?branch=master)](https://coveralls.io/github/alexmojaki/pure_eval?branch=master) [![Supports Python versions 3.5+](https://img.shields.io/pypi/pyversions/pure_eval.svg)](https://pypi.python.org/pypi/pure_eval) + +This is a Python package that lets you safely evaluate certain AST nodes without triggering arbitrary code that may have unwanted side effects. + +It can be installed from PyPI: + + pip install pure_eval + +To demonstrate usage, suppose we have an object defined as follows: + +```python +class Rectangle: + def __init__(self, width, height): + self.width = width + self.height = height + + @property + def area(self): + print("Calculating area...") + return self.width * self.height + + +rect = Rectangle(3, 5) +``` + +Given the `rect` object, we want to evaluate whatever expressions we can in this source code: + +```python +source = "(rect.width, rect.height, rect.area)" +``` + +This library works with the AST, so let's parse the source code and peek inside: + +```python +import ast + +tree = ast.parse(source) +the_tuple = tree.body[0].value +for node in the_tuple.elts: + print(ast.dump(node)) +``` + +Output: + +```python +Attribute(value=Name(id='rect', ctx=Load()), attr='width', ctx=Load()) +Attribute(value=Name(id='rect', ctx=Load()), attr='height', ctx=Load()) +Attribute(value=Name(id='rect', ctx=Load()), attr='area', ctx=Load()) +``` + +Now to actually use the library. First construct an Evaluator: + +```python +from pure_eval import Evaluator + +evaluator = Evaluator({"rect": rect}) +``` + +The argument to `Evaluator` should be a mapping from variable names to their values. Or if you have access to the stack frame where `rect` is defined, you can instead use: + +```python +evaluator = Evaluator.from_frame(frame) +``` + +Now to evaluate some nodes, using `evaluator[node]`: + +```python +print("rect.width:", evaluator[the_tuple.elts[0]]) +print("rect:", evaluator[the_tuple.elts[0].value]) +``` + +Output: + +``` +rect.width: 3 +rect: <__main__.Rectangle object at 0x105b0dd30> +``` + +OK, but you could have done the same thing with `eval`. The useful part is that it will refuse to evaluate the property `rect.area` because that would trigger unknown code. If we try, it'll raise a `CannotEval` exception. + +```python +from pure_eval import CannotEval + +try: + print("rect.area:", evaluator[the_tuple.elts[2]]) # fails +except CannotEval as e: + print(e) # prints CannotEval +``` + +To find all the expressions that can be evaluated in a tree: + +```python +for node, value in evaluator.find_expressions(tree): + print(ast.dump(node), value) +``` + +Output: + +```python +Attribute(value=Name(id='rect', ctx=Load()), attr='width', ctx=Load()) 3 +Attribute(value=Name(id='rect', ctx=Load()), attr='height', ctx=Load()) 5 +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +Name(id='rect', ctx=Load()) <__main__.Rectangle object at 0x105568d30> +``` + +Note that this includes `rect` three times, once for each appearance in the source code. Since all these nodes are equivalent, we can group them together: + +```python +from pure_eval import group_expressions + +for nodes, values in group_expressions(evaluator.find_expressions(tree)): + print(len(nodes), "nodes with value:", values) +``` + +Output: + +``` +1 nodes with value: 3 +1 nodes with value: 5 +3 nodes with value: <__main__.Rectangle object at 0x10d374d30> +``` + +If we want to list all the expressions in a tree, we may want to filter out certain expressions whose values are obvious. For example, suppose we have a function `foo`: + +```python +def foo(): + pass +``` + +If we refer to `foo` by its name as usual, then that's not interesting: + +```python +from pure_eval import is_expression_interesting + +node = ast.parse('foo').body[0].value +print(ast.dump(node)) +print(is_expression_interesting(node, foo)) +``` + +Output: + +```python +Name(id='foo', ctx=Load()) +False +``` + +But if we refer to it by a different name, then it's interesting: + +```python +node = ast.parse('bar').body[0].value +print(ast.dump(node)) +print(is_expression_interesting(node, foo)) +``` + +Output: + +```python +Name(id='bar', ctx=Load()) +True +``` + +In general `is_expression_interesting` returns False for the following values: +- Literals (e.g. `123`, `'abc'`, `[1, 2, 3]`, `{'a': (), 'b': ([1, 2], [3])}`) +- Variables or attributes whose name is equal to the value's `__name__`, such as `foo` above or `self.foo` if it was a method. +- Builtins (e.g. `len`) referred to by their usual name. + +To make things easier, you can combine finding expressions, grouping them, and filtering out the obvious ones with: + +```python +evaluator.interesting_expressions_grouped(root) +``` + +To get the source code of an AST node, I recommend [asttokens](https://github.com/gristlabs/asttokens). + +Here's a complete example that brings it all together: + +```python +from asttokens import ASTTokens +from pure_eval import Evaluator + +source = """ +x = 1 +d = {x: 2} +y = d[x] +""" + +names = {} +exec(source, names) +atok = ASTTokens(source, parse=True) +for nodes, value in Evaluator(names).interesting_expressions_grouped(atok.tree): + print(atok.get_text(nodes[0]), "=", value) +``` + +Output: + +```python +x = 1 +d = {1: 2} +y = 2 +d[x] = 2 +``` + + + + +%prep +%autosetup -n pure_eval-0.2.2 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-pure-eval -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 19 2023 Python_Bot - 0.2.2-1 +- Package Spec generated