python-pure-eval-0.2.2-1.oe24090>    f깤 ;G|`u` " [,ɷ DžmE-aIm@n俥auOĭi1Z`OOt)< CS97[gyw"Ժ` Mdl>H%:j'[h -=v]8X°gFVsj;;M ǘ$}/4s4 6\^O$|S;($fpP,cU)\IMJcFīqKxzb t=g(VO7GS#婄@(m){i *bXOuPj)?z, /5 lN--֜(6{}@VODRc } CCJ)| h#m&刪4[9936dc5b3593f3055ede2f311e9fcf02c51e9a17cf5d91dfd7d67547b534095ee578291470e9a6b3277a4fafcfd67eb36deb4b10lf 6-w>7d?dd " Qx|       (89:AFGH$I,R0X4Y<\\]d^def1Cpython-pure-eval0.2.21.oe2409Safely evaluate AST nodes without side effects [![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 ```f깞dc-64g.compass-ci5MIThttp://openeuler.orgUnspecifiedpure_eval-0.2.2.tar.gzhttp://github.com/alexmojaki/pure_evallinuxnoarchKGrf긻f긻2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3f35c974c26cd4731516297cdc7ea3f1586ffab84b81988c84f0ae377482d7ee0 rootrootrootrootpython3-pure-evalpython-pure-eval-help  python3-develpython3-pippython3-setuptoolspython3-setuptools_scmpython3-tomlrpmlib(CompressedFileNames)rpmlib(FileDigests)3.0.4-14.6.0-14.18.2dgdPython_Bot - 0.2.2-1- Package Spec generatednoarchdc-64g.compass-ci 17266589740.2.2-1.oe24090.2.2-1.oe2409pure_eval-0.2.2.tar.gzpython-pure-eval.speccpiogzip9utf-8ed0927fc300e7efbf215f3177287d11a28fc9de9f2c8afed8ec843de12052005f42d202a5e16aaf688848e9833d0b6c7e410d08f43901c495b6ee4ea5362a787 Name: python-pure-eval Version: 0.2.2 Release: 1 Summary: Safely evaluate AST nodes without side effects License: MIT URL: http://github.com/alexmojaki/pure_eval Source0: https://files.pythonhosted.org/packages/97/5a/0bc937c25d3ce4e0a74335222aee05455d6afa2888032185f8ab50cdf6fd/pure_eval-0.2.2.tar.gz BuildArch: noarch Requires: python3-pytest %description [![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 -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 [![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 [![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 cd '/home/lkp/rpmbuild/BUILD' rm -rf 'pure_eval-0.2.2' /usr/lib/rpm/rpmuncompress -x '/home/lkp/rpmbuild/SOURCES/pure_eval-0.2.2.tar.gz' STATUS=$? if [ $STATUS -ne 0 ]; then exit $STATUS fi cd 'pure_eval-0.2.2' /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w . \ CFLAGS="${CFLAGS:-${RPM_OPT_FLAGS}}" LDFLAGS="${LDFLAGS:-${RPM_LD_FLAGS}}"\ /usr/bin/python3 setup.py build --executable="/usr/bin/python3 -s" sleep 1 %install \ CFLAGS="${CFLAGS:-${RPM_OPT_FLAGS}}" LDFLAGS="${LDFLAGS:-${RPM_LD_FLAGS}}"\ /usr/bin/python3 setup.py install -O1 --skip-build --root /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64 install -d -m755 /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64//usr/share/doc/python-pure-eval if [ -d doc ]; then cp -arf doc /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64//usr/share/doc/python-pure-eval; fi if [ -d docs ]; then cp -arf docs /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64//usr/share/doc/python-pure-eval; fi if [ -d example ]; then cp -arf example /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64//usr/share/doc/python-pure-eval; fi if [ -d examples ]; then cp -arf examples /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64//usr/share/doc/python-pure-eval; fi pushd /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64 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 /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64/filelist.lst . mv /home/lkp/rpmbuild/BUILDROOT/python-pure-eval-0.2.2-1.oe2409.x86_64/doclist.lst . %files -n python3-pure-eval -f filelist.lst %dir /usr/lib/python3.11/site-packages/* %files help -f doclist.lst /usr/share/doc/* %changelog * Fri May 19 2023 Python_Bot - 0.2.2-1 - Package Spec generated ?&] mzڶmMOsm۶m۶m۶~nJnͽTRV~ps1abhedoVS0sDЊdhOGdQ^lM Lܘ\m,&csG'&'k;7߆\L@=78O}|!5O~ʘ<_j_xA; z,2!6# j,eqa PIhyBH}鵾ԲۣuX*TK^1c:9Rvv}Ú%g1cƊ^몹ګϗ7˶#؏DA_f|X6}w7+=Mh۹˱v+ \8nh^%_=+M NI5ez䰲eo;]>o\zA-_;~D1Q7k|Ӭ8^:}F}3D%f^qt6>^ ē_nWk4IC8L$Uy߇p`)n[lpԎ/?Ot>K]^0k )Zd)Ņݜg `p!pv Hܪ#4} ~#?oxSC>EPpI&b PR9Țy懿l=,ܮX愺љD4T,++"hP r:ncYEpcY>ͤ-GRLRU(2ۈHJ$?9)s9mӐv ΀ٕ8L@AT "|5T0)@`0}reۄ!Zd%z<>1xCKhㆵ狹υ,0@qG>ZFsM)@ w%ʃ/a?B좀+’_cLdw3֘sBaA@5h졅pDdQ':~MJA)_3%"&iJj&v )rYnK$E&S .NgާHt'RDq_'N5zdgz]~yxnoX^y2"2&U;fDұjzK!mX""؈`Zւv!\Z!߸c;ǠBe:* Qwr$L3j_j7xE N{ R@mD2WcfV1IBaZdv{ cyw!yD _nvKb78npx9 1K=0cCQ¾8(hH3P^'bJ(3_Z~jrq@+يj_BX=dX $q~YO?}"X-TMUԃ[h#CSߚԗGCL#7gܞ/ߗ' LZ>rgC $=]L. =_L/ -Lr.;]܂7 7z9Bg'5\]wPئtI Өk/3}3Ċ9z|]n\]#[w 'z=#-'J_BϏW/Jc-Xp旇}=>#~/RĞ>=9ߏ]<_h|1^d^L1;@'i O>TM괠'&m#윮.7dAySj*^_hs޼A\R[E,cGjXW]U1H%ak3Kw X7Bm t}v2 XĪ`PB=´Z \{d/>>k7 3I3gCF73<3rc;FH>FA<}PFqIdo;f$0G hdU'ΨŶ?Ţ06p=jmxik>4(d-_?U|ጋU/VF<TЖfbzzM* zSF`7{l<ErwT(}JAzjCd3mL Z)B :٬eoZ4UQt! uȞ][!v^pp_z77[j ~f0c6];?5[S¹O/%9P%,7qR!eM\Ԙͳ*͙E`{w2IA6AШ\~{{$VIʢDb|Ǥ*A?~8D0re|8Yf[} tp-/jʴ?Q52t|"0h#w3p[7|)_Mv<‹e4+>="YnF# ƒ`4pBٯd9ne[dݵݴkD$죟hDˍy]s+/%IkF p@ Eё f6ܝ̇ේT.f)N:'gOr4&@ \g\ʊUh>GH$\/N~|o+"(bo*)HmPaL=pЍ5hAdC'Czh1"ڵ(M(^MeX%,˷̱}HQ;* HUStU9,{'Z31h/,ˍݔiк̉]˺T!7"@y80gB$,ByKzttsGU||]Ƹ8;9mu0!Y@Opk|^+Pm||}et8v6~!e܉?~}Csɢ,e8U$yRrg;'jmauꚰݲr7&?oͣiY/D*/ᢆhn> kTP!*|_i$4{uM QqUIgbtape7aN7x7Ij*wqg׀R7]Gڳ::<- E ,އO|q 9\#eLyՇp7dXn2rD#֢x<`:O3:j+QgK3{#  $HpNHRBwjS ė(% iZUQ LUARt CFl>fL0'E6chj@Rsh7pl 檊jW"U@|@"?d@=)r? iuTiMV~9f=Ħ+fGoCP^,Rښ\{IC{/XBŸq-FӢq:`V7lR>4伟{[_@9(NFrG)G91!^QAhdbݺU"-Kk"HVR(7rh*6KUU#ͬ.D]=,4cO;z*P1 *ܥIfsa@(W{O޼ؑG^kr GH {Lzl!QTb, vͱE"y30ϟ<0I@+";B-ޒbC,Nd 86KdZIl(%&qk}/MYt%M~5~UabSCh}DmRvΡ:s誜wp_7 ^_'\n(&yoJ5ua~x^x\?0LcUWtc?K;v1<,,o(wkǗN|/7@` m:TX \XM6/?Lso-~tg |e{2e3B=GK׶_+vR>9.|kn|>a)S9{E1Dj0۠>Mgc+,'1<$xc,`t;C_\S%V̖f,DNwW&-f-38)[ |T=R'?7Bh.P{$j~};v}< @wI#ph;ƇgKoGg uX!rI؅b{kk'9bKގf ]I#ZȩJdNCLp]3bC]kVѬEc\וm` ^ x<ȼ}sej7y.OO5sNVz#qTF1ߔ^3U/zLx m >9*_6f2 b gY`8?ZewaU}mYFޢB=[q$FLU~._xYIti:f 'C $Q4b sF`ıi [𶥹DYmewmΩ9{&ĚSܢT_@y29UqU&Wy!ֽvjO=2h^0'>cfi0E C+Cm 0.+H J\e$Շgsu[q36ĊkbkL}#aQp+ ç Bs-OtZӻQ\3 'qƞG)ֱSW!k GUx U%?C8[sɡmřVgtV =hd ;)[:H͓+ZgL\-ڕPLO#|IJz̼-Da-T>ꠚn9Ⱥwᗭ)%iLm1=C$mGY[/ Ŗ߉zL L0 :iIJ+`qWkc=&b$eG+Z[n6]ߧW8;ΎؐÒ.#ݽSLc3ubLK/rmOЦ8kjM }B2#ŞfeEf,R Z4Ip\ n9NMU 6M%U  H~& c Ct>]Ut9'YڝB`Z[@ҡOV$ƸFB bFY68L+uT_LjP.nKY!xIiN 0ǖ笽tJIh^1qysP|bÕفHPV7@&9/,}}n*9+,gcocA0|WeXbalˁ\2)c@~P)2/*6HsN5"_[;Bf޶ f0C45Oٲ& C] wD XZ[INxVTПRےGkoU} ;|j4&s$R5ٿ}fU= - WilI^T6CW[hڈ|Qd 'ї)Ij\W5N尳PE /P/NV.]2|?%B+2!Q,e_|lnU8|TySɺŘJA&ɣٻc5\jo!`Vq pGJb }]~ hLyR 6\&7vb L?uBHT4inE2D)̡J%mҾdT^" (7%4`a1H*%;.N另u?Vfz'GE4z]HIJ$i`M̬p?x,>NKv`H Bp H-z\QI:O^ζP˷M0/|<>r$qɡr*QZbYK9l.cR%BRr L{H*Re57:'Np KJivi&@EلLMqqu!&'[o-2 &_&h(Uwd{T` bEv'Y]th/|1FyiLA=UKC?>zZ5!F Gmdr)'4%=C,4^\PC28 cL[S\&XfMMWĨg-qz_r8j>>0:?M D +pfyp ~Vӥݽ9ɬbn/4U/Y,ʙأEx}1px\fD ֲ"|Z#O1~JW;m/4ypT3,:jry)(?IuN!'YZL(>dd!Ht * #hSI0 `N<`*Ʊ E]>9!A@vVTb|1}9jPw5FoNNI$uنXJϪJ>.)BM=Wm`SWڼHѡkmA/R(0|;to3y#rW{$|qΠS {Yi$OD1@[oAp;7EY@]BeRY:!2'PZJVEP|a+ VzDC.ZeY}!hSY,-jU׉Ӟ^;eQ!kRk .-{nS'NǐCC\.˯:/UNWսXLbe޵XPu& n`)](|){~'{UIƈC5: PGi%sG.s*E܅|5f̐KLA񟂨c JyH$ӇzZZ4c6xדZ{{Ԏkij([6JWH8% ֤/{>C}{ {N*̖?u-so0&#(1{r#a$9V6fg7hLKC+M4\QJ֊|zi$iեE+U{.煷{ -XUXP~ V@9`#-0A+sfAW$yҎ[`SgV HI?8) WhP ~vp =Z'yo-d4`R`.l_(,"BOtZ("jN9I* G9MM]T+_@mӐf4B c>TvQHEAQeTLntt2=ʷ$Jno>u)N?%:OɈ5(S6Eҷլ)b'XRԷXDwbm~IA#9`2MX7{s4/X:3%z (V ՠ{!7f*XZ.w)L'UH^]/CrC/Wl382s xg YS9%~b||qU0vC¾  Y*@8-Gxt\G?érPQOY9ƪˆ*mswNtSEрZіv!^*=$"xJ=?mv*/F'6gK^jl%<.ՌZzoD:s"ejq:OUpؿn\7=՚T/jʀv~T/߾m`Q{g{ӡs‚?d_#6@O] >߶˗r6۶E t֣\zQ||(ng{=x6*V|c~o0C׭Yl>YNX /|ڝ߽ڮݸP=+6?ft]/ʒtk&j(eb&.{sN {W;;_n1#CףG~m7v3W6]4viRIP =W'Ȼ7)B ;ϕn.7h/wS]^7hY.a&# 8 9t?xU3rvz;^"~("~Ի\Uقq=!YOF }m0"t x?F`j/31!CMR^a/Ja :#0)iM; ] DMTR;"#n\hrѴ6"CB(e" CCPIp䧿t6FNqm Yg_>\Z2:b&@Frl9(3`o۞ē^IxĀwS:5(՞Z?-mMMA I #./.P'͜Fi&e$ezu8%v\;A_ ХM>$&jjNCL*M穂|`J9SxgI ɍ\vmvc;LԌSvk!;$1~k;VFMO@aLH8T AWQK}QC$9g.K$u5}U&U5kú70pڳȨJo5o4'14U\>E ՛cو6,+lfP- o]k@jY$rl*}ÒlTG!:2i DBA^DЄU-rȔ.ŒL~Qpu&9VOWӈA1%2li B[x3QM"Ƽc="ZJK`U JYÇRgM؉OJ`;~{C}(K'QDq[|"_P0Y=6L-m2{*&,< c_CO2yTy_X"12YՅa0]6J h/]½p,pLf?sou{l$uH 7 &;m46,L*} >~ذ!e{KH.:;" +3 rJl,x\EݍRdw6I ;\,76|,SyA,M8I*(NߪW`ݏt%&g;@ETWM5>Lhj Pg)A %˦4Xj!h^07 6irO6,Lh&!%|=Od4y~Kޟ@8L 4AzZ!ݛ=_@>G#>^t3 ]˄u$I_ mU,M7w*)~Q+%R X^vX4gߏ A :% [j )1q M)fbjNM/O|_3/M|'fFs`4_Q~S\!N}? Ty;=kpEs84;MEM~<]=BEc#`D8+=m`ً%'QP%Ht$i^1`lˮj.4Qx_SzZɟo>w眥; ?UEAQ~gڟ 4Kp(I$Y蛈U &w{K6t$ٟ}94Ya]ΐ+>:ˀKB#[7;,:NŮeAd!rVxGE \A ӈDGlC5cj5aHԯIJ¶CI؍v/$7A_v^rBD^dj摛˗dKADx>'C7m _$NfdczI kXNvow+?fy8} D-d $1y ^BG(0KÞHm EUb@kÁyD;o_"xh\ Bg`*J6`w|+IL*mIfhJ\\O] Nh1RIQZwbs݇bQ*Hc[6Ol}L(ߎvBGE]$6k$E.5YM,U;@CDpdpt\5$5}6)UKxZ449$saэ #T2-*/@Nn`7Rm(MDs"onυ+c)T:^_?48Oz5O$hzwkV h.6r4fSf8I2N8g$̔-zb^mt.%(磝PpῌIR^!t0DgV1PoQެf=LJe Ph M}*$/MϧvXדQ:-!M&eC箂R>su +bڜ:[ |"H7$wu3v0#~ ѲQEhnP|+Lm\2mmc]5j)1h {r rG=&݄àɖ;㼟9= 4toʴG?fÜT9KfGБ5Hp EbVx: t ]|,.;H}+ ]yM2Rի93İm}յP VO|OŊ}իx݄lO 1*NMb/~8"_w*S+Whd0H֋ާ; aހYdQ|0U#ʯ'&*;-9 q~k\_jԘ5 j7.8Jpۢg4ˤVD服NuȘb4ɳOܕC-˺qg-o|xi8sj/#, k/On׺wyC:#zdˈ-6O=zt_zϥǟbԭtk#v_ Oy5~af֧wo8<}I&Yȟdӄ)6J ?7cjhvLeϠ趓n<(8efCWw-Aoz-FF,S_+:gQ^8)N=V >UICO{J9c 2\.~=bgu[q36mKÞygtω>~_>T:ٽRۊ+!-TmyHBTo>^=7zg&7.YٷSܛ3x{iOqkfOiz#^ȟҮΛB; .]s8 E ~e8 #wU=$m|?˫Ox9fd6U|މwPQ-U\rq3ߜbQ첼wlEk-J,f;V12ey=;y*LsWdaDY圶ů#v=%>+g,Ia͕ҎZ8sF14 Z$SMȬ7 |}9Z ={l>n7$ilQiE勡v=]%R=M=CL9qMHzIhϻ⅗#7{d3U6uW䎂TK騣= ڄm)͹`9-7^],{G7ם 9o;tJNjmAMvY7c?ۭ7&,iZX%KݐYEu}QY3/(}( U]lf[s4iwכ=5sܨ?t~4rʥUYCTO.# 2c6/t.o^I ?ڡyE:f.#BV٣%kmZٻ+wQ8jאBfu(w;wtz-OݙJ67OUؾkɄ.wZw],k`-PF|* mʵG>4qȀP.s[Zxsqd-|wn\]'q.gqGJ%ewi -~w8//Xv yTvC596MٷBN`8uuXcI'Njy1x0;mq~I%Xcբu +TəPc#okU\>^?ϩ)WVS%I͙WSbf Θz}ע8q;v.UT4ە'V RXʾ2wq8?}E3\|yچޜM;ch*o Jܨ+M<s&)aXXŭo~)]^R4q${O]}nz?ds۳/vݣngНB3oy+g;*`7So=2JJaӭ.֜mCoU-xlNգO$WKVS;v؈_9>5|f.*nc<%mjj9A޻jM"ĬON^[%-#+G4ůay&7u-ܯ;_~r݆ʜ/"UdyM[=|э8xM9ePCǥ[{xSx$~K٫@buK6xOVK_fL=2{֨ZprUHN*6x's?r(pU_b}'wƭʯ<ϴv{'6o}5=S7V/6k|EϺY\qFavL8'[UvK~=;/VLȸ"Nw xbJHuIÎn>֡sߥ9J,c;wKtWD?`Пv^WTu>1K6x?v,KMă)y~Ց5-Z]|S¶fUzܳ>?VNLgߍ0gw4cM+%*~K6v洦Dk+R%l{׏+mWX}Wߛ7~PRmP焹mYlla!2}zX.^w%JJ  &dnd j-,QcRA0%h5XB"ӑ*9*B15ei)d8A3$)*c+S1:2SdKx&ERNBA, !qBY @"ÆJzrLSjgj*3}Nhyq X U#YI1,!RtXqs>nq ' C,c!pS&vPxb2.WR]~G2?+,5~"@5cu$M0^%9@tӤDR#O)DEspcuL l,%3NrGjHB&!4[g9387R1Br - /&%rCOMZf4S,IuzP'T %I mM%7A:齇[gD(IZBY%Ƣ*l,ҡ'a4X&5(FH`*:KFX48u"H(aXS@)5_h%h]!*'@@(أ T0C^0`N4@ 5=Ơ J_**a0@ibU'A%RC !T 8U P%A*Y ~ଐDD A4_-Mir08I&@,'LTW6 B{&X1݆`Ah#ABlFRH&5(M-T;$Q"I PBZ\1qPO͆qoԞ ;5|'wǹqw@n')輎 g!q 'ZnD~!R xPKpkY1P*8 2J-BП@*$T,7ހ\ )ߠձvԟQ%ӱ {;B8 PMBar/@1@i?a7.aDH@0'`Z!O @.u[C齎##i}3R8Kz:V&~.5KQh0fZ-=NvF 8AHt%aAPex<`"hc77[(=09TV=4xB!ܜyc3A0Ei=a Y/{ZӃ. >bD }BH$B#b0W9HEE 1̃_cmL.?ʨ+NxBXHJ Rt4$i%( H W ݵش $1xc@XK 2)A n!FOe ^O9k[}N9eוz0TW3z z n ~ݚru#Zm"Ao(Q^j1>Q{Wx*ao,%%K )-05.B!REOwZa RDeXc@u#p^ R #1Z*M*‘IMpͩ"sQO֯1C"k $N* Gj ̠)K:282[p ՄvPI 5tA  zOB!$ 1( QM*@ wѮT,@bTG