snail-lang 0.3.4__cp310-abi3-win_amd64.whl → 0.3.7__cp310-abi3-win_amd64.whl

snail/cli.py

@@ -21,6 +21,7 @@ def main(argv: list[str] | None = None) -> int:
     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("-I", "--no-auto-import", 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)
@@ -59,6 +60,7 @@ def main(argv: list[str] | None = None) -> int:
         argv=args,
         mode=mode,
         auto_print=not namespace.no_print,
+        auto_import=not namespace.no_auto_import,
         filename=filename,
     )
 

snail/runtime/__init__.py

@@ -1,16 +1,51 @@
 from __future__ import annotations
 
+import functools
+import importlib
+from typing import Any
+
 from .compact_try import compact_try
 from .regex import regex_compile, regex_search
 from .structured_accessor import (
-    JsonObject,
-    JsonPipelineWrapper,
-    StructuredAccessor,
-    json,
+    __snail_jmespath_query,
+    js,
 )
 from .subprocess import SubprocessCapture, SubprocessStatus
 
-__all__ = ["install_helpers"]
+__all__ = ["install_helpers", "AutoImportDict", "AUTO_IMPORT_NAMES"]
+
+# Names that can be auto-imported when first referenced.
+# Maps name -> (module, attribute) where attribute is None for whole-module imports.
+AUTO_IMPORT_NAMES: dict[str, tuple[str, str | None]] = {
+    # Whole module imports: import X
+    "sys": ("sys", None),
+    "os": ("os", None),
+    # Attribute imports: from X import Y
+    "Path": ("pathlib", "Path"),
+}
+
+
+class AutoImportDict(dict):
+    """A dict subclass that lazily imports allowed names on first access.
+
+    When a key lookup fails, if the key is in AUTO_IMPORT_NAMES,
+    the corresponding module/attribute is imported and stored in the dict.
+    Supports both whole-module imports (import sys) and attribute imports
+    (from pathlib import Path).
+    """
+
+    def __missing__(self, key: str) -> Any:
+        if key in AUTO_IMPORT_NAMES:
+            module_name, attr_name = AUTO_IMPORT_NAMES[key]
+            module = importlib.import_module(module_name)
+            value = getattr(module, attr_name) if attr_name else module
+            self[key] = value
+            return value
+        raise KeyError(key)
+
+
+def __snail_partial(func, /, *args, **kwargs):
+    return functools.partial(func, *args, **kwargs)
 
 
 def install_helpers(globals_dict: dict) -> None:
@@ -19,7 +54,6 @@ def install_helpers(globals_dict: dict) -> None:
     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
+    globals_dict["__snail_jmespath_query"] = __snail_jmespath_query
+    globals_dict["__snail_partial"] = __snail_partial
+    globals_dict["js"] = js

snail/runtime/structured_accessor.py

@@ -1,71 +1,75 @@
 from __future__ import annotations
 
 import json as _json
+import os as _os
 import sys as _sys
 
 from ..vendor import jmespath
 
 
-class StructuredAccessor:
-    def __init__(self, query: str) -> None:
-        self.query = query
+def __snail_jmespath_query(query: str):
+    """Create a callable that applies JMESPath 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)
+    Used by the $[query] syntax which lowers to __snail_jmespath_query(query).
+    """
 
+    def apply(data):
+        return jmespath.search(query, data)
 
-class JsonObject:
-    def __init__(self, data) -> None:
-        self.data = data
+    return apply
 
-    def __structured__(self, query: str):
-        return jmespath.search(query, self.data)
 
-    def __repr__(self) -> str:
-        return _json.dumps(self.data, indent=2)
+def _parse_jsonl(content: str):
+    lines = [line for line in content.splitlines() if line.strip()]
+    if not lines:
+        return []
 
-
-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."""
+    items = []
+    for line in lines:
+        try:
+            items.append(_json.loads(line))
+        except _json.JSONDecodeError as exc:
+            raise _json.JSONDecodeError(
+                f"Invalid JSONL line: {exc.msg}",
+                line,
+                exc.pos,
+            ) from exc
+    return items
+
+
+def js(input_data=None):
+    """Parse JSON from various input sources.
+
+    Returns the parsed Python object (dict, list, etc.) directly.
+    If called with no arguments, reads from stdin.
+    """
     if input_data is None:
-        return JsonPipelineWrapper()
+        input_data = _sys.stdin
 
     if isinstance(input_data, str):
         try:
-            data = _json.loads(input_data)
+            return _json.loads(input_data)
         except _json.JSONDecodeError:
-            with open(input_data, "r", encoding="utf-8") as handle:
-                data = _json.load(handle)
+            if _os.path.exists(input_data):
+                with open(input_data, "r", encoding="utf-8") as handle:
+                    content = handle.read()
+                try:
+                    return _json.loads(content)
+                except _json.JSONDecodeError:
+                    return _parse_jsonl(content)
+            else:
+                return _parse_jsonl(input_data)
     elif hasattr(input_data, "read"):
         content = input_data.read()
         if isinstance(content, bytes):
             content = content.decode("utf-8")
-        data = _json.loads(content)
+        try:
+            return _json.loads(content)
+        except _json.JSONDecodeError:
+            return _parse_jsonl(content)
     elif isinstance(input_data, (dict, list, int, float, bool)) or input_data is None:
-        data = input_data
+        return input_data
     else:
         raise TypeError(
-            f"json() input must be JSON-compatible, got {type(input_data).__name__}"
+            f"js() input must be JSON-compatible, got {type(input_data).__name__}"
         )
-
-    return JsonObject(data)

snail/runtime/subprocess.py

@@ -7,7 +7,7 @@ class SubprocessCapture:
     def __init__(self, cmd: str) -> None:
         self.cmd = cmd
 
-    def __pipeline__(self, input_data):
+    def __call__(self, input_data=None):
         try:
             if input_data is None:
                 completed = subprocess.run(
@@ -42,7 +42,7 @@ class SubprocessStatus:
     def __init__(self, cmd: str) -> None:
         self.cmd = cmd
 
-    def __pipeline__(self, input_data):
+    def __call__(self, input_data=None):
         try:
             if input_data is None:
                 subprocess.run(self.cmd, shell=True, check=True)

{snail_lang-0.3.4.dist-info → snail_lang-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.3.4
+Version: 0.3.7
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Provides-Extra: dev
@@ -64,7 +64,7 @@ The `?` operator makes error handling terse yet expressive:
 err = risky_operation()?
 
 # Provide a fallback value (exception available as $e)
-value = parse_json(data):{}?
+value = js(data):{}?
 details = fetch_url(url):"Error: {$e}"?
 
 # Access attributes directly
@@ -101,7 +101,7 @@ Built-in variables: `$l` (line), `$f` (fields), `$n` (line number), `$fn` (per-f
 
 ### Pipeline Operator
 
-The `|` operator enables data pipelining through objects that implement `__pipeline__`:
+The `|` operator enables data pipelining through pipeline-aware callables:
 
 ```snail
 # Pipe data to subprocess stdin
@@ -112,23 +112,37 @@ output = "foo\nbar" | $(grep foo) | $(wc -l)
 
 # Custom pipeline handlers
 class Doubler {
-    def __pipeline__(self, x) { return x * 2 }
+    def __call__(self, x) { return x * 2 }
 }
 doubled = 21 | Doubler()  # yields 42
+
+# Use placeholders to control where piped values land in calls
+greeting = "World" | greet("Hello ", _)  # greet("Hello ", "World")
+excited = "World" | greet(_, "!")        # greet("World", "!")
+formal = "World" | greet("Hello ", suffix=_)  # greet("Hello ", "World")
 ```
 
+When a pipeline targets a call expression, the left-hand value is passed to the
+resulting callable. If the call includes a single `_` placeholder, Snail substitutes
+the piped value at that position (including keyword arguments). Only one
+placeholder is allowed in a piped call. Outside of pipeline calls, `_` remains a
+normal identifier.
+
 ### JSON Queries with JMESPath
 
-Parse and query JSON data with the `json()` function and structured pipeline accessor:
+Parse and query JSON data with the `js()` function and structured pipeline accessor:
 
 ```snail
 # Parse JSON and query with $[jmespath]
-data = json($(curl -s api.example.com/users))
+data = js($(curl -s api.example.com/users))
 names = data | $[users[*].name]
 first_email = data | $[users[0].email]
 
 # Inline parsing and querying
-result = json('{"foo": 12}') | $[foo]
+result = js('{"foo": 12}') | $[foo]
+
+# JSONL parsing returns a list
+names = js('{"name": "Ada"}\n{"name": "Lin"}') | $[[*].name]
 ```
 
 ### Full Python Interoperability
@@ -147,7 +161,7 @@ filtered = df[df["value"] > 100]
 
 ```bash
 # Install from PyPI
-pip install snail
+pip install snail-lang
 
 # Run a one-liner
 snail "print('Hello, Snail!')"
@@ -179,10 +193,9 @@ flowchart TB
         C2[crates/snail-ast/src/awk.rs<br/>AwkProgram AST]
     end
 
-    subgraph Lowering["Lowering & Code Generation"]
+    subgraph Lowering["Lowering"]
         D1[crates/snail-lower/<br/>AST → Python AST Transform]
         D2[python/snail/runtime/<br/>Runtime Helpers]
-        D3[crates/snail-codegen/<br/>Python AST → Source Code]
     end
 
     subgraph Execution
@@ -198,9 +211,8 @@ flowchart TB
     C1 --> D1
     C2 --> D1
     D1 --> D2
-    D1 --> D3
-    D2 --> D3
-    D3 --> E1
+    D1 --> E1
+    D2 --> E1
     E1 --> E2
     E2 --> F[Python Execution]
 
@@ -218,7 +230,7 @@ flowchart TB
   - `$(cmd)` subprocess capture → `__SnailSubprocessCapture`
   - `@(cmd)` subprocess status → `__SnailSubprocessStatus`
   - Regex literals → `__snail_regex_search` and `__snail_regex_compile`
-- **Code Generation**: Converts Python AST to Python source for in-process execution
+- **Execution**: Compiles Python AST directly for in-process execution
 - **CLI**: Python wrapper (`python/snail/cli.py`) that executes via the extension module
 
 ## 📚 Documentation
@@ -333,7 +345,7 @@ python3 -m venv myenv
 source myenv/bin/activate  # On Windows: myenv\Scripts\activate
 
 # Install and run
-pip install snail
+pip install snail-lang
 snail "import sys; print(sys.prefix)"
 ```
 

{snail_lang-0.3.4.dist-info → snail_lang-0.3.7.dist-info}/RECORD

@@ -1,11 +1,11 @@
 snail\__init__.py,sha256=QQdNHRMalbxBvCW3RVDkMh-F4ScPOtikNbmkpC4NznE,282
-snail\_native.pyd,sha256=PZBCt77uUK4laSy-I0I0wFgrAUO9HaiD-JSXMTH-Www,1538048
-snail\cli.py,sha256=RimI2F9PzQkJ5jAePDlzwZ_Vkqtvdw2Fn65S8YvtrKs,1925
-snail\runtime\__init__.py,sha256=LgoUPIGA2saLTeiywITPOzjx1LG67nIJctkWxOJA4Sc,914
+snail\_native.pyd,sha256=bkJymYDAuavT8dk1cd-jII59pC74GdZrj2R8ERCpcA0,1511936
+snail\cli.py,sha256=m1b8qS7SgyiEnPeC6l5gqq_VTm3AO01s4yt5R-ywP44,2048
+snail\runtime\__init__.py,sha256=CZAaF3SHKUCuaEog6XnjcorchR19HKVWH4D92TYqOgU,2115
 snail\runtime\compact_try.py,sha256=GsGN8zJ_6kmv26_Wn1s9dfylcJjE0fZGQxplCR2Mx8A,392
 snail\runtime\regex.py,sha256=MH30z5yLiQrfk4uRWwVxneOvDbI8GCUP33Qhl8xvsHg,191
-snail\runtime\structured_accessor.py,sha256=fweg27DS2xqQ10vzGbdZtJtBMKrSbwujpkhNmZ5jcKc,2053
-snail\runtime\subprocess.py,sha256=gihvY_5Pi5uZAwYDgz94nqmVXAqgX1a4aASKd4o5wes,1953
+snail\runtime\structured_accessor.py,sha256=mX5kANTV-Y04TDOjhJdcFrl9zPcu4NgvLGWfzuyuNWM,2235
+snail\runtime\subprocess.py,sha256=ILDdfpqRXMFjWKYdpxQvEpie_31kItCuDO2WlsNpnks,1955
 snail\vendor\__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 snail\vendor\jmespath\LICENSE,sha256=2KWiDylgnlq10P3XDxl8OYugQB6n-HRR_M9FUsOlplI,1134
 snail\vendor\jmespath\__init__.py,sha256=uGroTH0i_1gETCVguY0L1EJiALD4b2Gr01KPySp2LJU,278
@@ -16,8 +16,8 @@ snail\vendor\jmespath\functions.py,sha256=YZ9H_JOmpn2-hHGX6Dif-9I2xb7w30fm-al8gA
 snail\vendor\jmespath\lexer.py,sha256=xM9tayCW9o9_wc7a8aAu563QCVJ2SlotHj5BDc78-80,9668
 snail\vendor\jmespath\parser.py,sha256=8FEJChdCFtdC0cq8TQdu2YxN5Y2ahZtFUkBkkUuTuzU,19423
 snail\vendor\jmespath\visitor.py,sha256=VN1KjK_Shmv4qTAVb8WaKOGC2LgCjo2xNg9k5CSFBv0,11129
-snail_lang-0.3.4.dist-info\METADATA,sha256=uHn9PY2IE9nqeaEchP-Eqa_77Bp_atcYACWufeQdbWE,9276
-snail_lang-0.3.4.dist-info\WHEEL,sha256=ZMDDxh9OPoaLQ4P2dJmgI1XsENYSzjzq8fErKKVw5iE,96
-snail_lang-0.3.4.dist-info\entry_points.txt,sha256=8u6pjHZtKGdaZQlr6yKbftplObC07caDZ44j5PIPU6M,39
-snail_lang-0.3.4.dist-info\licenses\LICENSE,sha256=iT_e39WExFFehp3Zh4faVe3dEv3BrhhX_v3obKdBM9M,1082
-snail_lang-0.3.4.dist-info\RECORD,,
+snail_lang-0.3.7.dist-info\METADATA,sha256=LLOmdEiFolJ9OqebnsL7D9EIF7YA5o-iUk4WkBszVpU,9856
+snail_lang-0.3.7.dist-info\WHEEL,sha256=ZMDDxh9OPoaLQ4P2dJmgI1XsENYSzjzq8fErKKVw5iE,96
+snail_lang-0.3.7.dist-info\entry_points.txt,sha256=8u6pjHZtKGdaZQlr6yKbftplObC07caDZ44j5PIPU6M,39
+snail_lang-0.3.7.dist-info\licenses\LICENSE,sha256=iT_e39WExFFehp3Zh4faVe3dEv3BrhhX_v3obKdBM9M,1082
+snail_lang-0.3.7.dist-info\RECORD,,