diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-pe.spec | 512 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 514 insertions, 0 deletions
@@ -0,0 +1 @@ +/pe-0.3.2.tar.gz diff --git a/python-pe.spec b/python-pe.spec new file mode 100644 index 0000000..90e593b --- /dev/null +++ b/python-pe.spec @@ -0,0 +1,512 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pe +Version: 0.3.2 +Release: 1 +Summary: Library for Parsing Expression Grammars (PEG) +License: MIT +URL: https://github.com/goodmami/pe/ +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/a7/e3/b351f5e5249e3e716ebfc6ea9070d45c38570ff7281e6b015ad664c177f1/pe-0.3.2.tar.gz + + +%description +**pe** is a library for parsing expressions, including [parsing +expression grammars] (PEGs). It aims to join the expressive power of +parsing expressions with the familiarity of regular expressions. For +example: +```python +>>> import pe +>>> pe.match(r'"-"? [0-9]+', '-38') # match an integer +<Match object; span=(0, 3), match='-38'> +``` +A grammar can be used for more complicated or recursive patterns: +```python +>>> float_parser = pe.compile(r''' +>>> float_parser.match('6.02e23') +<Match object; span=(0, 7), match='6.02e23'> +``` +[parsing expression grammars]: https://en.wikipedia.org/wiki/Parsing_expression_grammar +**Quick Links** +* [Documentation](docs/README.md) + - [Specification](docs/specification.md) + - [Guides](docs/guides/README.md) + - [API Documentation](docs/api/README.md) + - [FAQ](docs/faq.md) +* [Example Parsers](examples/) +## Features and Goals +* Grammar notation is backward-compatible with standard PEG with few extensions +* A [specification](docs/specification.md) describes the semantic + effect of parsing (e.g., for mapping expressions to function calls) +* Parsers are often faster than other parsing libraries, sometimes by + a lot; see the [benchmarks] +* The API is intuitive and familiar; it's modeled on the standard + API's [re] module +* Grammar definitions and parser implementations are separate + - Optimizations target the abstract grammar definitions + - Multiple parsers are available (currently [packrat](pe/packrat.py) + for recursive descent and [machine](pe/machine.py) for an + iterative "parsing machine" as from [Medeiros and Ierusalimschy, + 2008] and implemented in [LPeg]). +[benchmarks]: https://github.com/goodmami/python-parsing-benchmarks +[re]: https://docs.python.org/3/library/re.html +[Medeiros and Ierusalimschy, 2008]: http://www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf +## Syntax Overview +**pe** is backward compatible with standard PEG syntax and it is +conservative with extensions. +```regex +# terminals +. # any single character +"abc" # string literal +'abc' # string literal +[abc] # character class +# repeating expressions +e # exactly one +e? # zero or one (optional) +e* # zero or more +e+ # one or more +# combining expressions +e1 e2 # sequence of e1 and e2 +e1 / e2 # ordered choice of e1 and e2 +(e) # subexpression +# lookahead +&e # positive lookahead +!e # negative lookahead +# (extension) capture substring +~e # result of e is matched substring +# (extension) binding +name:e # bind result of e to 'name' +# grammars +Name <- ... # define a rule named 'Name' +``` +## Matching Inputs with Parsing Expressions +When a parsing expression matches an input, it returns a `Match` +object, which is similar to those of Python's +[re](https://docs.python.org/3/library/re.html) module for regular +expressions. By default, nothing is captured, but the capture operator +(`~`) emits the substring of the matching expression, similar to +regular expression's capturing groups: +```python +>>> e = pe.compile(r'[0-9] [.] [0-9]') +>>> m = e.match('1.4') +>>> m.group() +'1.4' +>>> m.groups() +() +>>> e = pe.compile(r'~([0-9] [.] [0-9])') +>>> m = e.match('1.4') +>>> m.group() +'1.4' +>>> m.groups() +('1.4',) +``` +### Value Bindings +A value binding extracts the emitted values of a match and associates +it with a name that is made available in the `Match.groupdict()` +dictionary. This is similar to named-capture groups in regular +expressions, except that it extracts the emitted values and not the +substring of the bound expression. +```python +>>> e = pe.compile(r'~[0-9] x:(~[.]) ~[0-9]') +>>> m = e.match('1.4') +>>> m.groups() +('1', '4') +>>> m.groupdict() +{'x': '.'} +``` +### Actions +Actions (also called "semantic actions") are callables that transform +parse results. When an arbitrary function is given, it is called as +follows: +``` python +func(*match.groups(), **match.groupdict()) +``` +The result of this function call becomes the only emitted value going +forward and all bound values are cleared. +For more control, **pe** provides the [Action] class and a number of +subclasses for various use-cases. These actions have access to more +information about a parse result and more control over the +match. For example, the [Pack] class takes a function and calls it +with the emitted values packed into a list: +``` python +func(match.groups()) +``` +And the [Join] class joins all emitted strings with a separator: +``` python +func(sep.join(match.groups()), **match.groupdict()) +``` +[Action]: docs/api/pe.actions.md#Action +[Pack]: docs/api/pe.actions.md#Pack +[Join]: docs/api/pe.actions.md#Join +### Example +Here is one way to parse a list of comma-separated integers: +```python +>>> from pe.actions import Pack +>>> p = pe.compile( +>>> m = p.match('[5,10,-15]') +>>> m.value() +[5, 10, -15] +``` +## Similar Projects +- [Lark](https://github.com/lark-parser/lark) (Python) +- [nom](https://github.com/Geal/nom) (Rust) +- [Parsimonious](https://github.com/erikrose/parsimonious) (Python) +- [Rosie](https://rosie-lang.org/) (Multiple bindings) +- [TatSu](https://tatsu.readthedocs.io/en/stable/) (Python) +- [PEG.js](https://github.com/pegjs/pegjs) (Javascript) +- [Pegged](https://github.com/PhilippeSigaud/Pegged) (D) +- [pegen](https://github.com/gvanrossum/pegen) (Python / C) +- [LPeg] (Lua) +[LPeg]: http://www.inf.puc-rio.br/~roberto/lpeg/ + +%package -n python3-pe +Summary: Library for Parsing Expression Grammars (PEG) +Provides: python-pe +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +BuildRequires: python3-cffi +BuildRequires: gcc +BuildRequires: gdb +%description -n python3-pe +**pe** is a library for parsing expressions, including [parsing +expression grammars] (PEGs). It aims to join the expressive power of +parsing expressions with the familiarity of regular expressions. For +example: +```python +>>> import pe +>>> pe.match(r'"-"? [0-9]+', '-38') # match an integer +<Match object; span=(0, 3), match='-38'> +``` +A grammar can be used for more complicated or recursive patterns: +```python +>>> float_parser = pe.compile(r''' +>>> float_parser.match('6.02e23') +<Match object; span=(0, 7), match='6.02e23'> +``` +[parsing expression grammars]: https://en.wikipedia.org/wiki/Parsing_expression_grammar +**Quick Links** +* [Documentation](docs/README.md) + - [Specification](docs/specification.md) + - [Guides](docs/guides/README.md) + - [API Documentation](docs/api/README.md) + - [FAQ](docs/faq.md) +* [Example Parsers](examples/) +## Features and Goals +* Grammar notation is backward-compatible with standard PEG with few extensions +* A [specification](docs/specification.md) describes the semantic + effect of parsing (e.g., for mapping expressions to function calls) +* Parsers are often faster than other parsing libraries, sometimes by + a lot; see the [benchmarks] +* The API is intuitive and familiar; it's modeled on the standard + API's [re] module +* Grammar definitions and parser implementations are separate + - Optimizations target the abstract grammar definitions + - Multiple parsers are available (currently [packrat](pe/packrat.py) + for recursive descent and [machine](pe/machine.py) for an + iterative "parsing machine" as from [Medeiros and Ierusalimschy, + 2008] and implemented in [LPeg]). +[benchmarks]: https://github.com/goodmami/python-parsing-benchmarks +[re]: https://docs.python.org/3/library/re.html +[Medeiros and Ierusalimschy, 2008]: http://www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf +## Syntax Overview +**pe** is backward compatible with standard PEG syntax and it is +conservative with extensions. +```regex +# terminals +. # any single character +"abc" # string literal +'abc' # string literal +[abc] # character class +# repeating expressions +e # exactly one +e? # zero or one (optional) +e* # zero or more +e+ # one or more +# combining expressions +e1 e2 # sequence of e1 and e2 +e1 / e2 # ordered choice of e1 and e2 +(e) # subexpression +# lookahead +&e # positive lookahead +!e # negative lookahead +# (extension) capture substring +~e # result of e is matched substring +# (extension) binding +name:e # bind result of e to 'name' +# grammars +Name <- ... # define a rule named 'Name' +``` +## Matching Inputs with Parsing Expressions +When a parsing expression matches an input, it returns a `Match` +object, which is similar to those of Python's +[re](https://docs.python.org/3/library/re.html) module for regular +expressions. By default, nothing is captured, but the capture operator +(`~`) emits the substring of the matching expression, similar to +regular expression's capturing groups: +```python +>>> e = pe.compile(r'[0-9] [.] [0-9]') +>>> m = e.match('1.4') +>>> m.group() +'1.4' +>>> m.groups() +() +>>> e = pe.compile(r'~([0-9] [.] [0-9])') +>>> m = e.match('1.4') +>>> m.group() +'1.4' +>>> m.groups() +('1.4',) +``` +### Value Bindings +A value binding extracts the emitted values of a match and associates +it with a name that is made available in the `Match.groupdict()` +dictionary. This is similar to named-capture groups in regular +expressions, except that it extracts the emitted values and not the +substring of the bound expression. +```python +>>> e = pe.compile(r'~[0-9] x:(~[.]) ~[0-9]') +>>> m = e.match('1.4') +>>> m.groups() +('1', '4') +>>> m.groupdict() +{'x': '.'} +``` +### Actions +Actions (also called "semantic actions") are callables that transform +parse results. When an arbitrary function is given, it is called as +follows: +``` python +func(*match.groups(), **match.groupdict()) +``` +The result of this function call becomes the only emitted value going +forward and all bound values are cleared. +For more control, **pe** provides the [Action] class and a number of +subclasses for various use-cases. These actions have access to more +information about a parse result and more control over the +match. For example, the [Pack] class takes a function and calls it +with the emitted values packed into a list: +``` python +func(match.groups()) +``` +And the [Join] class joins all emitted strings with a separator: +``` python +func(sep.join(match.groups()), **match.groupdict()) +``` +[Action]: docs/api/pe.actions.md#Action +[Pack]: docs/api/pe.actions.md#Pack +[Join]: docs/api/pe.actions.md#Join +### Example +Here is one way to parse a list of comma-separated integers: +```python +>>> from pe.actions import Pack +>>> p = pe.compile( +>>> m = p.match('[5,10,-15]') +>>> m.value() +[5, 10, -15] +``` +## Similar Projects +- [Lark](https://github.com/lark-parser/lark) (Python) +- [nom](https://github.com/Geal/nom) (Rust) +- [Parsimonious](https://github.com/erikrose/parsimonious) (Python) +- [Rosie](https://rosie-lang.org/) (Multiple bindings) +- [TatSu](https://tatsu.readthedocs.io/en/stable/) (Python) +- [PEG.js](https://github.com/pegjs/pegjs) (Javascript) +- [Pegged](https://github.com/PhilippeSigaud/Pegged) (D) +- [pegen](https://github.com/gvanrossum/pegen) (Python / C) +- [LPeg] (Lua) +[LPeg]: http://www.inf.puc-rio.br/~roberto/lpeg/ + +%package help +Summary: Development documents and examples for pe +Provides: python3-pe-doc +%description help +**pe** is a library for parsing expressions, including [parsing +expression grammars] (PEGs). It aims to join the expressive power of +parsing expressions with the familiarity of regular expressions. For +example: +```python +>>> import pe +>>> pe.match(r'"-"? [0-9]+', '-38') # match an integer +<Match object; span=(0, 3), match='-38'> +``` +A grammar can be used for more complicated or recursive patterns: +```python +>>> float_parser = pe.compile(r''' +>>> float_parser.match('6.02e23') +<Match object; span=(0, 7), match='6.02e23'> +``` +[parsing expression grammars]: https://en.wikipedia.org/wiki/Parsing_expression_grammar +**Quick Links** +* [Documentation](docs/README.md) + - [Specification](docs/specification.md) + - [Guides](docs/guides/README.md) + - [API Documentation](docs/api/README.md) + - [FAQ](docs/faq.md) +* [Example Parsers](examples/) +## Features and Goals +* Grammar notation is backward-compatible with standard PEG with few extensions +* A [specification](docs/specification.md) describes the semantic + effect of parsing (e.g., for mapping expressions to function calls) +* Parsers are often faster than other parsing libraries, sometimes by + a lot; see the [benchmarks] +* The API is intuitive and familiar; it's modeled on the standard + API's [re] module +* Grammar definitions and parser implementations are separate + - Optimizations target the abstract grammar definitions + - Multiple parsers are available (currently [packrat](pe/packrat.py) + for recursive descent and [machine](pe/machine.py) for an + iterative "parsing machine" as from [Medeiros and Ierusalimschy, + 2008] and implemented in [LPeg]). +[benchmarks]: https://github.com/goodmami/python-parsing-benchmarks +[re]: https://docs.python.org/3/library/re.html +[Medeiros and Ierusalimschy, 2008]: http://www.inf.puc-rio.br/~roberto/docs/ry08-4.pdf +## Syntax Overview +**pe** is backward compatible with standard PEG syntax and it is +conservative with extensions. +```regex +# terminals +. # any single character +"abc" # string literal +'abc' # string literal +[abc] # character class +# repeating expressions +e # exactly one +e? # zero or one (optional) +e* # zero or more +e+ # one or more +# combining expressions +e1 e2 # sequence of e1 and e2 +e1 / e2 # ordered choice of e1 and e2 +(e) # subexpression +# lookahead +&e # positive lookahead +!e # negative lookahead +# (extension) capture substring +~e # result of e is matched substring +# (extension) binding +name:e # bind result of e to 'name' +# grammars +Name <- ... # define a rule named 'Name' +``` +## Matching Inputs with Parsing Expressions +When a parsing expression matches an input, it returns a `Match` +object, which is similar to those of Python's +[re](https://docs.python.org/3/library/re.html) module for regular +expressions. By default, nothing is captured, but the capture operator +(`~`) emits the substring of the matching expression, similar to +regular expression's capturing groups: +```python +>>> e = pe.compile(r'[0-9] [.] [0-9]') +>>> m = e.match('1.4') +>>> m.group() +'1.4' +>>> m.groups() +() +>>> e = pe.compile(r'~([0-9] [.] [0-9])') +>>> m = e.match('1.4') +>>> m.group() +'1.4' +>>> m.groups() +('1.4',) +``` +### Value Bindings +A value binding extracts the emitted values of a match and associates +it with a name that is made available in the `Match.groupdict()` +dictionary. This is similar to named-capture groups in regular +expressions, except that it extracts the emitted values and not the +substring of the bound expression. +```python +>>> e = pe.compile(r'~[0-9] x:(~[.]) ~[0-9]') +>>> m = e.match('1.4') +>>> m.groups() +('1', '4') +>>> m.groupdict() +{'x': '.'} +``` +### Actions +Actions (also called "semantic actions") are callables that transform +parse results. When an arbitrary function is given, it is called as +follows: +``` python +func(*match.groups(), **match.groupdict()) +``` +The result of this function call becomes the only emitted value going +forward and all bound values are cleared. +For more control, **pe** provides the [Action] class and a number of +subclasses for various use-cases. These actions have access to more +information about a parse result and more control over the +match. For example, the [Pack] class takes a function and calls it +with the emitted values packed into a list: +``` python +func(match.groups()) +``` +And the [Join] class joins all emitted strings with a separator: +``` python +func(sep.join(match.groups()), **match.groupdict()) +``` +[Action]: docs/api/pe.actions.md#Action +[Pack]: docs/api/pe.actions.md#Pack +[Join]: docs/api/pe.actions.md#Join +### Example +Here is one way to parse a list of comma-separated integers: +```python +>>> from pe.actions import Pack +>>> p = pe.compile( +>>> m = p.match('[5,10,-15]') +>>> m.value() +[5, 10, -15] +``` +## Similar Projects +- [Lark](https://github.com/lark-parser/lark) (Python) +- [nom](https://github.com/Geal/nom) (Rust) +- [Parsimonious](https://github.com/erikrose/parsimonious) (Python) +- [Rosie](https://rosie-lang.org/) (Multiple bindings) +- [TatSu](https://tatsu.readthedocs.io/en/stable/) (Python) +- [PEG.js](https://github.com/pegjs/pegjs) (Javascript) +- [Pegged](https://github.com/PhilippeSigaud/Pegged) (D) +- [pegen](https://github.com/gvanrossum/pegen) (Python / C) +- [LPeg] (Lua) +[LPeg]: http://www.inf.puc-rio.br/~roberto/lpeg/ + +%prep +%autosetup -n pe-0.3.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-pe -f filelist.lst +%dir %{python3_sitearch}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 17 2023 Python_Bot <Python_Bot@openeuler.org> - 0.3.2-1 +- Package Spec generated @@ -0,0 +1 @@ +2eaa317a41d5afbfc4e37b3e4e1db0aa pe-0.3.2.tar.gz |