tinysexpr 1.0__tar.gz

tinysexpr-1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sebastian Hack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tinysexpr-1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: tinysexpr
+Version: 1.0
+Summary: A very simple S-expression parser that tries to make as little fuss as possible.
+Author-email: Sebastian Hack <contact@s-hack.de>
+License: MIT
+Project-URL: GitHub, https://github.com/shack/tinysexpr
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# S-Expression Parser
+
+A very simple [S-expression](https://en.m.wikipedia.org/wiki/S-expression) parser that tries to make as little fuss as possible.
+
+## Example
+
+This module provides a single function
+```
+def read(file_like, delims=DEFAULT_DELIMS, comment_char=';', atom_handler=lambda x: x):
+```
+that returns the read S-expression.
+Reading
+```
+(a b c (123 e f () x))
+```
+returns
+```
+['a', 'b', 'c', ['123', 'e', 'f', [], 'x']]
+```
+
+## Atoms
+
+`a`, `b`, `c` in the above example are called **atoms**.
+Atoms are parsed using two different rules:
+1. Every sequence that does not contain a whitespace, opening of closing parenthesis or the comment character is an atom.
+2. Every sequence that starts and ends with a **delimiter** is an atom.
+   The default delimiters are `"` for strings with the usual escape characters (`\n`, `\t`, `\"`, `\\`, ...) and `|` without escape characters.
+   Using the `delims` parameter, you can customize the delimiters and their escape sequences.
+
+## Details
+
+The parameters of `read` are:
+1. `file_like`: An object that is [file like](https://docs.python.org/3/glossary.html#term-file-object) i.e. provides a `read` method.
+2. `delims`: A map of delimiters used to surround atoms that contain spaces.
+   Commonly these are double-quotes to represent strings as in `"Hello"` or
+   vertical bars to allow for symbols that contain spaces as in `|some symbol|`.
+   The map `DEFAULT_DELIMS` specifies delimiters for strings and symbols.
+3. `comment_char`: The character that starts a single line comment.
+   The default value is `;`.
+4. `atom_handler`: A function that is called when an atom is parsed.
+   This function is passed a string that consists of the text of the parsed
+   atom. The function can convert this string into something else and the
+   returned value is used to construct the S-expression.
+   For example, this allows for converting digit sequences into ints.

tinysexpr-1.0/README.md

@@ -0,0 +1,44 @@
+# S-Expression Parser
+
+A very simple [S-expression](https://en.m.wikipedia.org/wiki/S-expression) parser that tries to make as little fuss as possible.
+
+## Example
+
+This module provides a single function
+```
+def read(file_like, delims=DEFAULT_DELIMS, comment_char=';', atom_handler=lambda x: x):
+```
+that returns the read S-expression.
+Reading
+```
+(a b c (123 e f () x))
+```
+returns
+```
+['a', 'b', 'c', ['123', 'e', 'f', [], 'x']]
+```
+
+## Atoms
+
+`a`, `b`, `c` in the above example are called **atoms**.
+Atoms are parsed using two different rules:
+1. Every sequence that does not contain a whitespace, opening of closing parenthesis or the comment character is an atom.
+2. Every sequence that starts and ends with a **delimiter** is an atom.
+   The default delimiters are `"` for strings with the usual escape characters (`\n`, `\t`, `\"`, `\\`, ...) and `|` without escape characters.
+   Using the `delims` parameter, you can customize the delimiters and their escape sequences.
+
+## Details
+
+The parameters of `read` are:
+1. `file_like`: An object that is [file like](https://docs.python.org/3/glossary.html#term-file-object) i.e. provides a `read` method.
+2. `delims`: A map of delimiters used to surround atoms that contain spaces.
+   Commonly these are double-quotes to represent strings as in `"Hello"` or
+   vertical bars to allow for symbols that contain spaces as in `|some symbol|`.
+   The map `DEFAULT_DELIMS` specifies delimiters for strings and symbols.
+3. `comment_char`: The character that starts a single line comment.
+   The default value is `;`.
+4. `atom_handler`: A function that is called when an atom is parsed.
+   This function is passed a string that consists of the text of the parsed
+   atom. The function can convert this string into something else and the
+   returned value is used to construct the S-expression.
+   For example, this allows for converting digit sequences into ints.

tinysexpr-1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinysexpr"
+authors = [
+    {name = "Sebastian Hack", email = "contact@s-hack.de"},
+]
+version = "1.0"
+description = "A very simple S-expression parser that tries to make as little fuss as possible."
+readme = "README.md"
+license = { text="MIT" }
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+]
+
+[project.urls]
+"GitHub" = "https://github.com/shack/tinysexpr"

tinysexpr-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tinysexpr-1.0/src/tinysexpr.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: tinysexpr
+Version: 1.0
+Summary: A very simple S-expression parser that tries to make as little fuss as possible.
+Author-email: Sebastian Hack <contact@s-hack.de>
+License: MIT
+Project-URL: GitHub, https://github.com/shack/tinysexpr
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# S-Expression Parser
+
+A very simple [S-expression](https://en.m.wikipedia.org/wiki/S-expression) parser that tries to make as little fuss as possible.
+
+## Example
+
+This module provides a single function
+```
+def read(file_like, delims=DEFAULT_DELIMS, comment_char=';', atom_handler=lambda x: x):
+```
+that returns the read S-expression.
+Reading
+```
+(a b c (123 e f () x))
+```
+returns
+```
+['a', 'b', 'c', ['123', 'e', 'f', [], 'x']]
+```
+
+## Atoms
+
+`a`, `b`, `c` in the above example are called **atoms**.
+Atoms are parsed using two different rules:
+1. Every sequence that does not contain a whitespace, opening of closing parenthesis or the comment character is an atom.
+2. Every sequence that starts and ends with a **delimiter** is an atom.
+   The default delimiters are `"` for strings with the usual escape characters (`\n`, `\t`, `\"`, `\\`, ...) and `|` without escape characters.
+   Using the `delims` parameter, you can customize the delimiters and their escape sequences.
+
+## Details
+
+The parameters of `read` are:
+1. `file_like`: An object that is [file like](https://docs.python.org/3/glossary.html#term-file-object) i.e. provides a `read` method.
+2. `delims`: A map of delimiters used to surround atoms that contain spaces.
+   Commonly these are double-quotes to represent strings as in `"Hello"` or
+   vertical bars to allow for symbols that contain spaces as in `|some symbol|`.
+   The map `DEFAULT_DELIMS` specifies delimiters for strings and symbols.
+3. `comment_char`: The character that starts a single line comment.
+   The default value is `;`.
+4. `atom_handler`: A function that is called when an atom is parsed.
+   This function is passed a string that consists of the text of the parsed
+   atom. The function can convert this string into something else and the
+   returned value is used to construct the S-expression.
+   For example, this allows for converting digit sequences into ints.

tinysexpr-1.0/src/tinysexpr.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+pyproject.toml
+src/tinysexpr.py
+src/tinysexpr.egg-info/PKG-INFO
+src/tinysexpr.egg-info/SOURCES.txt
+src/tinysexpr.egg-info/dependency_links.txt
+src/tinysexpr.egg-info/top_level.txt

tinysexpr-1.0/src/tinysexpr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tinysexpr-1.0/src/tinysexpr.egg-info/top_level.txt

@@ -0,0 +1 @@
+tinysexpr

tinysexpr-1.0/src/tinysexpr.py

@@ -0,0 +1,156 @@
+from io import StringIO
+
+import pytest
+
+_UNEXPECTED_EOF = 'unexpected end of file'
+
+class SyntaxError(Exception):
+    def __init__(self, msg):
+        self.value = msg
+
+    def __str__(self):
+        return self.value
+
+DEFAULT_DELIMS = {
+    '"': ('\\', { 'n': '\n', 't': '\t', 'r': '\r', '\\': '\\', '"': '"' }),
+    '|': (None, {})
+}
+
+def read(file_like, delims=DEFAULT_DELIMS, comment_char=';', atom_handler=lambda x: x):
+    """Parse an S-expression from a file-like object.
+
+    The function takes the following arguments:
+    `file_like`: An object that is file like, i.e. provides a `read` method.
+    `delims`: A map of delimiters used to surround atoms that contain spaces.
+        Commonly these are double-quotes to represent strings as in `"Hello"` or vertical bars to allow for symbols that contain spaces as in `|some symbol|`.
+        The map maps the delimiter character to a tuple of two elements: the escape character and a map of escape sequences.
+        See `DEFAULT_DELIMS` for an example.
+        The map `DEFAULT_DELIMS` specifies delimiters for strings and symbols.
+    `comment_char`: The character that starts a single line comment.
+        The default value is `;`.
+    `atom_handler`: A function that is called when an atom is parsed.
+        This function is passed a string that consists of the text of the parsed atom. The function can convert this string into something else and the returned value is used to construct the S-expression.
+
+    The function returns the parsed S-expression as a nested list.
+    When a parse error is encountered, a `SyntaxError` is raised with a message that describes the error.
+    """
+
+    sym_delim = { c for c in '()' + comment_char + ''.join(delims.keys()) }
+    ch = file_like.read(1)
+    row = 1
+    col = 1
+
+    def curr():
+        return ch
+
+    def next():
+        nonlocal ch, row, col
+        ch = file_like.read(1)
+        if ch == '\n':
+            row += 1
+            col = 1
+        else:
+            col += 1
+        return ch
+
+    def skip_ws():
+        while True:
+            c = curr()
+            if c.isspace():
+                next()
+            elif c == comment_char:
+                while c and c != '\n':
+                    c = next()
+            else:
+                break
+        return c
+
+    def error(msg):
+        raise SyntaxError(f'{msg} at {row}:{col}')
+
+    def parse():
+
+        def read_delim(delim, delim_info):
+            escape_char, escape_map = delim_info
+            read = [curr()]
+            c = next()
+            while c:
+                match c:
+                    case _ if c == escape_char:
+                        c = next()
+                        if c in escape_map:
+                            read.append(escape_map[c])
+                        else:
+                            error(f"invalid escape character '{c}'")
+                    case _ if c == delim:
+                        read.append(c)
+                        next()
+                        return ''.join(read)
+                    case _:
+                        read.append(c)
+                c = next()
+
+        def read_atom():
+            read = []
+            c = curr()
+            while c and not c.isspace() and c not in sym_delim:
+                read.append(c)
+                c = next()
+            return ''.join(read)
+
+        exp = []
+        while True:
+            c = skip_ws()
+            if not c:
+                error(_UNEXPECTED_EOF)
+            match c:
+                case '(':
+                    next()
+                    s = parse()
+                    exp.append(s)
+                case ')':
+                    next()
+                    return exp
+                case _ if c in delims:
+                    exp.append(atom_handler(read_delim(c, delims[c])))
+                case _:
+                    assert not c.isspace()
+                    exp.append(atom_handler(read_atom()))
+
+    c = skip_ws()
+    if c == '(':
+        next()
+    else:
+        error(f"expected '(', got '{c}'")
+    return parse()
+
+@pytest.mark.parametrize("input,expected", [
+    ('()', []),
+    ('(|a b c| || "abc\\"def" |abcgf xs!!|)', ['|a b c|', '||', '"abc"def"', '|abcgf xs!!|']),
+    ('(abc b0!@#$% c-d)', ['abc', 'b0!@#$%', 'c-d']),
+    (u'(1😀)', ['1😀']),
+    ('(a b c (d e f () |x yz|))', ['a', 'b', 'c', ['d', 'e', 'f', [], '|x yz|']]),
+    ('(1 (2 3) (4 5) 6 (7 (8 9)))', ['1', ['2', '3'], ['4', '5'], '6', ['7', ['8', '9']]]),
+    ('(1 (2 3) (4 5)); 6 (7 (8 9)))', ['1', ['2', '3'], ['4', '5']]),
+])
+def test_correct(input, expected):
+    assert read(StringIO(input)) == expected
+
+@pytest.mark.parametrize("input,msg", [
+    ('', _UNEXPECTED_EOF),
+    ('abc', "expected '(', got 'a'"),
+    ('(a', _UNEXPECTED_EOF),
+    ('|a b c', _UNEXPECTED_EOF),
+    ('"abc"cde"', _UNEXPECTED_EOF),
+    ('"abc\\9cde"', "invalid escape character"),
+    ('(1 (2 3) (4 5) 6 (7 (8 9))', _UNEXPECTED_EOF),
+])
+def test_error(input, msg):
+    with pytest.raises(SyntaxError) as e:
+        read(StringIO(input))
+        assert msg in str(e)
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) > 1:
+        print(read(open(sys.argv[1], 'rt')))