snail-lang 0.2.0__cp310-abi3-manylinux_2_34_x86_64.whl

snail/__init__.py

@@ -0,0 +1,10 @@
+from ._native import compile, exec, parse
+
+try:
+    from importlib.metadata import version
+
+    __version__ = version("snail")
+except Exception:  # pragma: no cover - during development
+    __version__ = "0.0.0"
+
+__all__ = ["compile", "exec", "parse", "__version__"]

snail/cli.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__, exec, parse
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    return argparse.ArgumentParser(
+        prog="snail",
+        description="Snail programming language interpreter",
+        usage="snail [options] -f <file> [args]...\n       snail [options] <code> [args]...",
+        add_help=True,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    parser.add_argument("-f", dest="file", metavar="file")
+    parser.add_argument("-a", "--awk", action="store_true")
+    parser.add_argument("-P", "--no-print", action="store_true")
+    parser.add_argument("--parse-only", action="store_true")
+    parser.add_argument("-v", "--version", action="store_true")
+    parser.add_argument("args", nargs=argparse.REMAINDER)
+
+    namespace = parser.parse_args(argv)
+
+    if namespace.version:
+        print(__version__)
+        return 0
+
+    mode = "awk" if namespace.awk else "snail"
+
+    if namespace.file:
+        path = Path(namespace.file)
+        try:
+            source = path.read_text()
+        except OSError as exc:
+            print(f"failed to read {path}: {exc}", file=sys.stderr)
+            return 1
+        filename = str(path)
+        args = [filename, *namespace.args]
+    else:
+        if not namespace.args:
+            print("no input provided", file=sys.stderr)
+            return 1
+        source = namespace.args[0]
+        filename = "<cmd>"
+        args = ["--", *namespace.args[1:]]
+
+    if namespace.parse_only:
+        parse(source, mode=mode, filename=filename)
+        return 0
+
+    return exec(
+        source,
+        argv=args,
+        mode=mode,
+        auto_print=not namespace.no_print,
+        filename=filename,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

snail/runtime/__init__.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from .compact_try import compact_try
+from .regex import regex_compile, regex_search
+from .structured_accessor import (
+    JsonObject,
+    JsonPipelineWrapper,
+    StructuredAccessor,
+    json,
+)
+from .subprocess import SubprocessCapture, SubprocessStatus
+
+__all__ = ["install_helpers"]
+
+
+def install_helpers(globals_dict: dict) -> None:
+    globals_dict["__snail_compact_try"] = compact_try
+    globals_dict["__snail_regex_search"] = regex_search
+    globals_dict["__snail_regex_compile"] = regex_compile
+    globals_dict["__SnailSubprocessCapture"] = SubprocessCapture
+    globals_dict["__SnailSubprocessStatus"] = SubprocessStatus
+    globals_dict["__SnailStructuredAccessor"] = StructuredAccessor
+    globals_dict["__SnailJsonObject"] = JsonObject
+    globals_dict["__SnailJsonPipelineWrapper"] = JsonPipelineWrapper
+    globals_dict["json"] = json

snail/runtime/compact_try.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+def compact_try(expr_fn, fallback_fn=None):
+    try:
+        return expr_fn()
+    except Exception as exc:
+        if fallback_fn is None:
+            fallback_member = getattr(exc, "__fallback__", None)
+            if callable(fallback_member):
+                return fallback_member()
+            return exc
+        return fallback_fn(exc)

snail/runtime/regex.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import re
+
+
+def regex_search(value, pattern):
+    return re.search(pattern, value)
+
+
+def regex_compile(pattern):
+    return re.compile(pattern)

snail/runtime/structured_accessor.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import json as _json
+import sys as _sys
+
+from ..vendor import jmespath
+
+
+class StructuredAccessor:
+    def __init__(self, query: str) -> None:
+        self.query = query
+
+    def __pipeline__(self, obj):
+        if not hasattr(obj, "__structured__"):
+            raise TypeError(
+                "Pipeline target must implement __structured__, "
+                f"got {type(obj).__name__}"
+            )
+        return obj.__structured__(self.query)
+
+
+class JsonObject:
+    def __init__(self, data) -> None:
+        self.data = data
+
+    def __structured__(self, query: str):
+        return jmespath.search(query, self.data)
+
+    def __repr__(self) -> str:
+        return _json.dumps(self.data, indent=2)
+
+
+class JsonPipelineWrapper:
+    """Wrapper for json() to support pipeline operator without blocking stdin."""
+
+    def __pipeline__(self, input_data):
+        return json(input_data)
+
+    def __structured__(self, query: str):
+        data = json(_sys.stdin)
+        return data.__structured__(query)
+
+    def __repr__(self) -> str:
+        data = json(_sys.stdin)
+        return repr(data)
+
+
+def json(input_data=None):
+    """Parse JSON from various input sources."""
+    if input_data is None:
+        return JsonPipelineWrapper()
+
+    if isinstance(input_data, str):
+        try:
+            data = _json.loads(input_data)
+        except _json.JSONDecodeError:
+            with open(input_data, "r", encoding="utf-8") as handle:
+                data = _json.load(handle)
+    elif hasattr(input_data, "read"):
+        content = input_data.read()
+        if isinstance(content, bytes):
+            content = content.decode("utf-8")
+        data = _json.loads(content)
+    elif isinstance(input_data, (dict, list, int, float, bool)) or input_data is None:
+        data = input_data
+    else:
+        raise TypeError(
+            f"json() input must be JSON-compatible, got {type(input_data).__name__}"
+        )
+
+    return JsonObject(data)

snail/runtime/subprocess.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import subprocess
+
+
+class SubprocessCapture:
+    def __init__(self, cmd: str) -> None:
+        self.cmd = cmd
+
+    def __pipeline__(self, input_data):
+        try:
+            if input_data is None:
+                completed = subprocess.run(
+                    self.cmd,
+                    shell=True,
+                    check=True,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                )
+            else:
+                if not isinstance(input_data, (str, bytes)):
+                    input_data = str(input_data)
+                completed = subprocess.run(
+                    self.cmd,
+                    shell=True,
+                    check=True,
+                    text=True,
+                    input=input_data,
+                    stdout=subprocess.PIPE,
+                )
+            return completed.stdout.rstrip("\n")
+        except subprocess.CalledProcessError as exc:
+
+            def __fallback(exc=exc):
+                raise exc
+
+            exc.__fallback__ = __fallback
+            raise
+
+
+class SubprocessStatus:
+    def __init__(self, cmd: str) -> None:
+        self.cmd = cmd
+
+    def __pipeline__(self, input_data):
+        try:
+            if input_data is None:
+                subprocess.run(self.cmd, shell=True, check=True)
+            else:
+                if not isinstance(input_data, (str, bytes)):
+                    input_data = str(input_data)
+                subprocess.run(
+                    self.cmd,
+                    shell=True,
+                    check=True,
+                    text=True,
+                    input=input_data,
+                )
+            return 0
+        except subprocess.CalledProcessError as exc:
+
+            def __fallback(exc=exc):
+                return exc.returncode
+
+            exc.__fallback__ = __fallback
+            raise

snail/vendor/jmespath/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+
+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.

snail/vendor/jmespath/__init__.py

@@ -0,0 +1,12 @@
+from . import parser
+from .visitor import Options
+
+__version__ = "1.0.1"
+
+
+def compile(expression):
+    return parser.Parser().parse(expression)
+
+
+def search(expression, data, options=None):
+    return parser.Parser().parse(expression).search(data, options=options)

snail/vendor/jmespath/ast.py

@@ -0,0 +1,90 @@
+# AST nodes have this structure:
+# {"type": <node type>", children: [], "value": ""}
+
+
+def comparator(name, first, second):
+    return {'type': 'comparator', 'children': [first, second], 'value': name}
+
+
+def current_node():
+    return {'type': 'current', 'children': []}
+
+
+def expref(expression):
+    return {'type': 'expref', 'children': [expression]}
+
+
+def function_expression(name, args):
+    return {'type': 'function_expression', 'children': args, 'value': name}
+
+
+def field(name):
+    return {"type": "field", "children": [], "value": name}
+
+
+def filter_projection(left, right, comparator):
+    return {'type': 'filter_projection', 'children': [left, right, comparator]}
+
+
+def flatten(node):
+    return {'type': 'flatten', 'children': [node]}
+
+
+def identity():
+    return {"type": "identity", 'children': []}
+
+
+def index(index):
+    return {"type": "index", "value": index, "children": []}
+
+
+def index_expression(children):
+    return {"type": "index_expression", 'children': children}
+
+
+def key_val_pair(key_name, node):
+    return {"type": "key_val_pair", 'children': [node], "value": key_name}
+
+
+def literal(literal_value):
+    return {'type': 'literal', 'value': literal_value, 'children': []}
+
+
+def multi_select_dict(nodes):
+    return {"type": "multi_select_dict", "children": nodes}
+
+
+def multi_select_list(nodes):
+    return {"type": "multi_select_list", "children": nodes}
+
+
+def or_expression(left, right):
+    return {"type": "or_expression", "children": [left, right]}
+
+
+def and_expression(left, right):
+    return {"type": "and_expression", "children": [left, right]}
+
+
+def not_expression(expr):
+    return {"type": "not_expression", "children": [expr]}
+
+
+def pipe(left, right):
+    return {'type': 'pipe', 'children': [left, right]}
+
+
+def projection(left, right):
+    return {'type': 'projection', 'children': [left, right]}
+
+
+def subexpression(children):
+    return {"type": "subexpression", 'children': children}
+
+
+def slice(start, end, step):
+    return {"type": "slice", "children": [start, end, step]}
+
+
+def value_projection(left, right):
+    return {'type': 'value_projection', 'children': [left, right]}

snail/vendor/jmespath/compat.py

@@ -0,0 +1,19 @@
+import sys
+import inspect
+from itertools import zip_longest
+
+
+text_type = str
+string_type = str
+
+
+def with_str_method(cls):
+    # In python3, we don't need to do anything, we return a str type.
+    return cls
+
+def with_repr_method(cls):
+    return cls
+
+def get_methods(cls):
+    for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+        yield name, method

snail/vendor/jmespath/exceptions.py

@@ -0,0 +1,137 @@
+from .compat import with_str_method
+
+
+class JMESPathError(ValueError):
+    pass
+
+
+@with_str_method
+class ParseError(JMESPathError):
+    _ERROR_MESSAGE = "Invalid jmespath expression"
+
+    def __init__(self, lex_position, token_value, token_type, msg=_ERROR_MESSAGE):
+        super(ParseError, self).__init__(lex_position, token_value, token_type)
+        self.lex_position = lex_position
+        self.token_value = token_value
+        self.token_type = token_type.upper()
+        self.msg = msg
+        # Whatever catches the ParseError can fill in the full expression
+        self.expression = None
+
+    def __str__(self):
+        # self.lex_position +1 to account for the starting double quote char.
+        underline = " " * (self.lex_position + 1) + "^"
+        return (
+            "%s: Parse error at column %s, "
+            'token "%s" (%s), for expression:\n"%s"\n%s'
+            % (
+                self.msg,
+                self.lex_position,
+                self.token_value,
+                self.token_type,
+                self.expression,
+                underline,
+            )
+        )
+
+
+@with_str_method
+class IncompleteExpressionError(ParseError):
+    def set_expression(self, expression):
+        self.expression = expression
+        self.lex_position = len(expression)
+        self.token_type = None
+        self.token_value = None
+
+    def __str__(self):
+        # self.lex_position +1 to account for the starting double quote char.
+        underline = " " * (self.lex_position + 1) + "^"
+        return 'Invalid jmespath expression: Incomplete expression:\n"%s"\n%s' % (
+            self.expression,
+            underline,
+        )
+
+
+@with_str_method
+class LexerError(ParseError):
+    def __init__(self, lexer_position, lexer_value, message, expression=None):
+        self.lexer_position = lexer_position
+        self.lexer_value = lexer_value
+        self.message = message
+        super(LexerError, self).__init__(lexer_position, lexer_value, message)
+        # Whatever catches LexerError can set this.
+        self.expression = expression
+
+    def __str__(self):
+        underline = " " * self.lexer_position + "^"
+        return "Bad jmespath expression: %s:\n%s\n%s" % (
+            self.message,
+            self.expression,
+            underline,
+        )
+
+
+@with_str_method
+class ArityError(ParseError):
+    def __init__(self, expected, actual, name):
+        self.expected_arity = expected
+        self.actual_arity = actual
+        self.function_name = name
+        self.expression = None
+
+    def __str__(self):
+        return "Expected %s %s for function %s(), received %s" % (
+            self.expected_arity,
+            self._pluralize("argument", self.expected_arity),
+            self.function_name,
+            self.actual_arity,
+        )
+
+    def _pluralize(self, word, count):
+        if count == 1:
+            return word
+        else:
+            return word + "s"
+
+
+@with_str_method
+class VariadictArityError(ArityError):
+    def __str__(self):
+        return "Expected at least %s %s for function %s(), received %s" % (
+            self.expected_arity,
+            self._pluralize("argument", self.expected_arity),
+            self.function_name,
+            self.actual_arity,
+        )
+
+
+@with_str_method
+class JMESPathTypeError(JMESPathError):
+    def __init__(self, function_name, current_value, actual_type, expected_types):
+        self.function_name = function_name
+        self.current_value = current_value
+        self.actual_type = actual_type
+        self.expected_types = expected_types
+
+    def __str__(self):
+        return (
+            "In function %s(), invalid type for value: %s, "
+            'expected one of: %s, received: "%s"'
+            % (
+                self.function_name,
+                self.current_value,
+                self.expected_types,
+                self.actual_type,
+            )
+        )
+
+
+class EmptyExpressionError(JMESPathError):
+    def __init__(self):
+        super(EmptyExpressionError, self).__init__(
+            "Invalid JMESPath expression: cannot be empty."
+        )
+
+
+class UnknownFunctionError(JMESPathError):
+    pass