lispython 0.3.1__tar.gz → 0.3.2__tar.gz

{lispython-0.3.1 → lispython-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lispython
-Version: 0.3.1
+Version: 0.3.2
 Summary: Lisp-like Syntax for Python with Lisp-like Macros
 Project-URL: Homepage, https://jetack.github.io/lispython
 Project-URL: Repository, https://github.com/jetack/lispython

{lispython-0.3.1 → lispython-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lispython"
-version = "0.3.1"
+version = "0.3.2"
 description = "Lisp-like Syntax for Python with Lisp-like Macros"
 authors = [{ name = "Jetack", email = "jetack23@gmail.com" }]
 license = { text = "MIT" }

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/core/compiler/expr.py

@@ -359,20 +359,15 @@ def paren_compiler(sexp, ctx):
 
 def slice_compile(sexp):
     [_, *args] = sexp.list
-    args = deque(args)
+    assert 2 <= len(args) <= 3 # temporarily block length 1 slice for breaking change alert
+    [lower, upper, step] = args if len(args) == 3 else args + ["_"] if len(args) == 2 else ["_"] + args + ["_"]
     args_dict = {}
-    if args:
-        lower = args.popleft()
-        if lower != "None" and lower != "_":
-            args_dict["lower"] = expr_compile(lower)
-    if args:
-        upper = args.popleft()
-        if upper != "None" and upper != "_":
-            args_dict["upper"] = expr_compile(upper)
-    if args:
-        step = args.popleft()
-        if step != "None" and step != "_":
-            args_dict["step"] = expr_compile(step)
+    if lower != "None" and lower != "_":
+        args_dict["lower"] = expr_compile(lower)
+    if upper != "None" and upper != "_":
+        args_dict["upper"] = expr_compile(upper)
+    if step != "None" and step != "_":
+        args_dict["step"] = expr_compile(step)
     return ast.Slice(**args_dict, **sexp.position_info)
 
 

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/core/macro.py

@@ -13,7 +13,7 @@ def define_macro(sexp, scope, include_meta=True):
     transformed = defmacro_transform(sexp)
     eval(
         compile(
-            ast.Interactive(body=macroexpand_then_compile([transformed])),
+            ast.Interactive(body=macroexpand_then_compile([transformed], include_meta=include_meta)),
             "macro-defining",
             "single",
         ),
@@ -26,7 +26,7 @@ def require_macro(sexp, scope, include_meta=True):
     transformed = require_transform(sexp)
     eval(
         compile(
-            ast.Interactive(body=macroexpand_then_compile([transformed])),
+            ast.Interactive(body=macroexpand_then_compile([transformed], include_meta=include_meta)),
             "macro-requiring",
             "single",
         ),
@@ -49,14 +49,18 @@ def macroexpand_1(sexp, scope=globals()):
 def macroexpand_1_and_check(sexp, scope=globals(), in_quasi=False, include_meta=True):
     expanded = False
     if isinstance(sexp, QuasiQuote):
-        sexp.value, expanded = macroexpand_1_and_check(sexp.value, scope, in_quasi=True)
+        sexp.value, expanded = macroexpand_1_and_check(
+            sexp.value, scope, in_quasi=True, include_meta=include_meta
+        )
     elif isinstance(sexp, Quote):
         pass
     elif isinstance(sexp, Unquote):
-        sexp.value, expanded = macroexpand_1_and_check(sexp.value, scope)
+        sexp.value, expanded = macroexpand_1_and_check(
+            sexp.value, scope, include_meta=include_meta
+        )
     elif isinstance(sexp, Wrapper):
         sexp.value, expanded = macroexpand_1_and_check(
-            sexp.value, scope, in_quasi=in_quasi
+            sexp.value, scope, in_quasi=in_quasi, include_meta=include_meta
         )
     elif isinstance(sexp, Expression) and len(sexp) > 0:
         [op, *operands] = sexp.list
@@ -70,7 +74,7 @@ def macroexpand_1_and_check(sexp, scope=globals(), in_quasi=False, include_meta=
         else:
             expanded_list, expanded_feedbacks = zip(
                 *map(
-                    lambda x: macroexpand_1_and_check(x, scope, in_quasi=in_quasi),
+                    lambda x: macroexpand_1_and_check(x, scope, in_quasi=in_quasi, include_meta=include_meta),
                     sexp.list,
                 )
             )

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/core/meta_functions.py

@@ -122,6 +122,6 @@ if __name__ == "__main__":
     path = osp.abspath(__file__)
     with open(path, "r") as f:
         org = f.read()
-    translated = l2py_s(org)
+    translated = l2py_s(org, no_lispy=True)
     with open(osp.join(osp.dirname(path), "core", "meta_functions.py"), "w") as f:
         f.write(translated)

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/core/parser.py

@@ -26,9 +26,17 @@ def tokenize(src):
     )
     number_simple = "|".join(scientific_simples + float_simples + [int_simple])
     complex_simple = f"(?:(?:{number_simple})[+-])?(?:{number_simple})j"
+    # F-string pattern with nested quotes in braces: f"...{expr "str"}..."
+    inner_str = r'\"(?:[^\"\\]|\\.)*\"'
+    brace_content = r'(?:[^{}\"\\]|\\.|\{[^{}]*\}|' + inner_str + r')*'
+    brace_expr = r'\{' + brace_content + r'\}'
+    f_string_content = r'(?:[^\"{}\\]|\\.|' + brace_expr + r')*'
+    f_string_pattern = r'f\"' + f_string_content + r'\"'
     pattern_labels = [
         ["\\^?\\*{0,2}[\\(\\{\\[]", "opening"],
         ["[\\)\\}\\]]", "closing"],
+        # F-string pattern must come before regular string patterns
+        [f_string_pattern, '"'],
         *list(
             zip(
                 map(
@@ -260,15 +268,52 @@ def string_parse(token, tktype, position_info):
 conversion_dict = {"!s": 115, "!r": 114, "!a": 97}
 
 
+def find_format_spec_separator(piece):
+    """Find the index of ':' that separates expression from format spec.
+    Only matches ':' at top level (not inside strings or brackets)."""
+    depth = 0
+    in_string = None
+    i = 0
+    while i < len(piece):
+        char = piece[i]
+        if in_string:
+            if char == '\\' and i + 1 < len(piece):
+                i += 2
+                continue
+            str_len = len(in_string)
+            if piece[i:i+str_len] == in_string:
+                in_string = None
+                i += str_len
+                continue
+        else:
+            if piece[i:i+3] in ('"""', "'''"):
+                in_string = piece[i:i+3]
+                i += 3
+                continue
+            elif char in ('"', "'"):
+                in_string = char
+            elif char in '([{':
+                depth += 1
+            elif char in ')]}':
+                depth -= 1
+            elif char == ':' and depth == 0:
+                return i
+        i += 1
+    return -1
+
+
 def f_string_parse(prefix, content, tktype, position_info):
     splitted = re.split("[\\{\\}]", content)
     processed = []
     splitted.pop() if splitted[-1] == "" else None
     for [i, piece] in enumerate(splitted):
         if i % 2:
-            if ":" in piece:
-                [*quarks, format_spec] = piece.split(":")
-                piece = ":".join(quarks)
+            # Unescape \" to " (backslash-quote is escape for quotes inside f-string braces)
+            piece = piece.replace('\\"', '"')
+            sep_idx = find_format_spec_separator(piece)
+            if sep_idx >= 0:
+                format_spec = piece[sep_idx + 1:]
+                piece = piece[:sep_idx]
             else:
                 format_spec = None
             if piece[-2:] in conversion_dict:

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/core_meta_functions.lpy

@@ -58,7 +58,7 @@
   (with [(open path "r") as f]
     (= org (f.read)))
 
-  (= translated (l2py-s org))
+  (= translated (l2py-s org :no-lispy True))
 
   (with [(open (-> path
                    (osp.dirname)

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/macros/sugar.lpy

@@ -44,7 +44,7 @@
   (return `(- ~elt 1)))
 
 (defmacro ++ [elt]
-  (return `(:= ~elt (+ ~elt 1))))
+  (return `(+= ~elt 1)))
 
 (defmacro -- [elt]
-  (return `(:= ~elt (- ~elt 1))))
+  (return `(-= ~elt 1)))

{lispython-0.3.1 → lispython-0.3.2}/src/lispy/tools.lpy

@@ -89,8 +89,11 @@
 (argparser.add-argument "--meta"
                         :dest "include_meta"
                         :action "store_true")
+(argparser.add-argument "--no-lispy"
+                        :dest "no_lispy"
+                        :action "store_true")
 
-(def l2py-s [src :include-meta False :fresh-scope False :package ""]
+(def l2py-s [src :include-meta False :fresh-scope False :package "" :no-lispy False]
   "Translate lispy source string to Python source string"
   (if fresh-scope
       (= scope {"__builtins__" __builtins__
@@ -98,9 +101,11 @@
                 "__macro_namespace" {}})
       (= scope SCOPE))
   (= pysrc (src-to-python src :include-meta include_meta :scope scope))
-  (return pysrc))
+  (if no_lispy
+      (return pysrc))
+  (return (+ "import lispy\n\n" pysrc)))
 
-(def l2py-f [file-path :include-meta False]
+(def l2py-f [file-path :include-meta False :no-lispy False]
   "Translate lispy file to Python source string (standalone with sys.path setup)"
   (= script-dir (osp.dirname (osp.abspath file-path)))
   (if (not (in script-dir sys.path))
@@ -121,13 +126,13 @@
   (with [(open file-path "rb") as f]
     (= src (.decode (f.read) "utf-8")))
   (= pkg (detect-package-name :path file-path))
-  (return (+ (l2py-s src :include-meta include_meta :fresh-scope True :package pkg) "\n")))
+  (return (+ (l2py-s src :include-meta include_meta :fresh-scope True :package pkg :no-lispy no_lispy) "\n")))
 
 (def l2py []
   "CLI entry point: parse args and translate file"
   (= [args more-args] (argparser.parse-known-args))
   (= file (osp.join (os.getcwd) (sub more-args 0)))
-  (print (l2py-f file :include-meta args.include_meta)))
+  (print (l2py-f file :include-meta args.include_meta :no-lispy args.no_lispy)))
 
 (def read-multiline-input [prompt_str]
   (= paren-depth 0)
@@ -173,9 +178,13 @@
   )
 
 (def repl [:translate False]
+  ;; Add current directory to sys.path for local imports
+  (= cwd (os.getcwd))
+  (if (not (in cwd sys.path))
+      (sys.path.insert 0 cwd))
   (= scope SCOPE)
   (eval-and-print "(require lispy.macros *)
-(from pprint [pprint])")
+(from pprint [pprint])" scope)
   (while True
     (try
       (do

lispython-0.3.2/tests/test_include_meta.py

@@ -0,0 +1,37 @@
+from lispy.tools import l2py_s
+
+
+def test_include_meta_flag_false():
+    src = "(defmacro m [x] x)"
+    out = l2py_s(src, include_meta=False)
+    # When include_meta is False, the defmacro form itself should not appear in the output
+    assert "defmacro" not in out and "def m" not in out
+
+
+def test_include_meta_flag_true():
+    src = "(defmacro m [x] x)"
+    out = l2py_s(src, include_meta=True)
+    # When include_meta is True, there should be some Python produced for the macro definition
+    assert "def" in out or "__macro_namespace" in out
+
+
+def test_include_meta_nested():
+    src = "(list (defmacro m [x] x) 1)"
+    out_false = l2py_s(src, include_meta=False)
+    # Nested defmacro should not appear when include_meta is False
+    assert "defmacro" not in out_false and "def m" not in out_false and "__macro_namespace" not in out_false
+
+    out_true = l2py_s(src, include_meta=True)
+    # With include_meta True the macro definition/import should be present
+    assert "def" in out_true or "__macro_namespace" in out_true
+
+
+def test_import_lispy_default_and_no_lispy():
+    src = "(+ 1 2)"
+    out_default = l2py_s(src)
+    # By default we should prepend import lispy
+    assert out_default.startswith("import lispy")
+
+    out_no_lispy = l2py_s(src, no_lispy=True)
+    # With no_lispy True we should not add the import
+    assert not out_no_lispy.startswith("import lispy")

{lispython-0.3.1 → lispython-0.3.2}/tests/test_literal.py

@@ -45,6 +45,21 @@ c"''') == "'a\\nb\\nc'"
             ast.parse('f"sin({a}) is {sin(a):.3}"')
         )
 
+    def test_f_string_with_nested_quotes(self):
+        # F-string with nested double-quoted string inside braces
+        # Uses raw string to have literal backslash-quote as in .lpy files
+        assert stmt_to_dump(
+            r'f"Started at {(.strftime (datetime.now) \"%Y-%m-%d %H:%M:%S\")}"'
+        ) == ast.dump(
+            ast.parse('f"Started at {datetime.now().strftime(\'%Y-%m-%d %H:%M:%S\')}"')
+        )
+
+    def test_f_string_with_colon_in_nested_string(self):
+        # Colon inside nested string should not be treated as format spec
+        assert stmt_to_dump(r'f"time: {(.get d \"H:M:S\")}"') == ast.dump(
+            ast.parse('f"time: {d.get(\'H:M:S\')}"')
+        )
+
 
 class TestListMethods:
     def test_list(self):

lispython-0.3.2/tests/test_meta_functions.py

@@ -0,0 +1,26 @@
+import os.path as osp
+
+from lispy.tools import l2py_s
+
+
+class TestMetaFunctionsSync:
+    """Test that core/meta_functions.py matches the transpiled result of core_meta_functions.lpy"""
+
+    def test_meta_functions_in_sync(self):
+        """core/meta_functions.py should match transpiled core_meta_functions.lpy"""
+        base_dir = osp.dirname(osp.dirname(osp.abspath(__file__)))
+        lpy_path = osp.join(base_dir, "src", "lispy", "core_meta_functions.lpy")
+        py_path = osp.join(base_dir, "src", "lispy", "core", "meta_functions.py")
+
+        with open(lpy_path, "r") as f:
+            lpy_src = f.read()
+
+        with open(py_path, "r") as f:
+            py_contents = f.read()
+
+        transpiled = l2py_s(lpy_src)
+
+        assert transpiled == py_contents, (
+            "core/meta_functions.py is out of sync with core_meta_functions.lpy. "
+            "Run `lispy src/lispy/core_meta_functions.lpy` to regenerate."
+        )

{lispython-0.3.1 → lispython-0.3.2}/uv.lock

@@ -238,7 +238,7 @@ wheels = [
 
 [[package]]
 name = "lispython"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 
 [package.optional-dependencies]