lispython 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lispython
-Version: 0.3.0
+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
@@ -67,9 +67,12 @@ lpy -m unittest
 # Todo
 ## Environment
 - [ ] Test on more python versions
-- [ ] Some IDE plugins like hy-mode and jedhy for better editing experience.
+- [ ] REPL should track history and arrow key navigation
+- [ ] REPL multi-line input support
+- [ ] Better compileation error messages
 ## Macro System
 - [ ] `as->` macro for syntactic sugar
 - [ ] `gensym` for avoiding name collision
 ## Python AST
-- [ ] `type_comment` never considered. Later, it should be covered
+- [ ] `type_comment` never considered. Later, it should be covered
+- [ ] Any missing AST nodes in the version 3.12+

{lispython-0.3.0 → lispython-0.3.2}/README.md

@@ -46,9 +46,12 @@ lpy -m unittest
 # Todo
 ## Environment
 - [ ] Test on more python versions
-- [ ] Some IDE plugins like hy-mode and jedhy for better editing experience.
+- [ ] REPL should track history and arrow key navigation
+- [ ] REPL multi-line input support
+- [ ] Better compileation error messages
 ## Macro System
 - [ ] `as->` macro for syntactic sugar
 - [ ] `gensym` for avoiding name collision
 ## Python AST
-- [ ] `type_comment` never considered. Later, it should be covered
+- [ ] `type_comment` never considered. Later, it should be covered
+- [ ] Any missing AST nodes in the version 3.12+

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

@@ -1,6 +1,6 @@
 [project]
 name = "lispython"
-version = "0.3.0"
+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.0 → 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.0 → 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.0 → lispython-0.3.2}/src/lispy/core/meta_functions.py

@@ -34,6 +34,18 @@ def require_transform(sexp):
         [macro_names] = optional
     else:
         macro_names = None
+    module_name_str = str(module_name).replace("-", "_")
+    is_relative = module_name_str.startswith(".")
+    import_call = (
+        Paren(
+            Symbol("importlib.import-module"),
+            module_name_str,
+            Keyword(Symbol("package")),
+            Symbol("__package__"),
+        )
+        if is_relative
+        else Paren(Symbol("importlib.import-module"), module_name_str)
+    )
     return Paren(
         Symbol("do"),
         Paren(Symbol("import"), Symbol("importlib")),
@@ -41,13 +53,7 @@ def require_transform(sexp):
             Symbol("="),
             Symbol("___imported-macros"),
             Paren(
-                Symbol("getattr"),
-                Paren(
-                    Symbol("importlib.import-module"),
-                    str(module_name).replace("-", "_"),
-                ),
-                String('"__macro_namespace"'),
-                Brace(),
+                Symbol("getattr"), import_call, String('"__macro_namespace"'), Brace()
             ),
         ),
         Paren(
@@ -111,11 +117,11 @@ def require_transform(sexp):
 if __name__ == "__main__":
     import os.path as osp
 
-    from lispy.tools import l2py_f
+    from lispy.tools import l2py_s
 
     path = osp.abspath(__file__)
     with open(path, "r") as f:
         org = f.read()
-    translated = l2py_f(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.0 → lispython-0.3.2}/src/lispy/core/parser.py

@@ -7,8 +7,12 @@ from lispy.core.utils import augassignop_dict
 
 
 def tokenize(src):
-    # Remove commas except those following { or ( with optional whitespace
-    src = re.sub(r"([{(]\s*),|,", lambda m: m.group(0) if m.group(1) else " ", src)
+    # Remove commas except those following { or ( with optional whitespace, but preserve commas in strings
+    src = re.sub(
+        r'(\w*"""(?:[^\\"]|\\.)*"""|\w*\'\'\'(?:[^\\\']|\\.)*\'\'\'|\w*"(?:[^\\"]|\\.)*"|[{(]\s*,)|,',
+        lambda m: m.group(1) if m.group(1) else " ",
+        src,
+    )
     lines = src.split("\n")
     tokens = deque([])
     int_simple = r"\d+[\dA-Za-z]*(?:_[\dA-Za-z]+)*"
@@ -22,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(
@@ -256,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.0 → lispython-0.3.2}/src/lispy/core_meta_functions.lpy

@@ -21,11 +21,15 @@
   (if optional
       (= [macro-names] optional)
       (= macro-names None))
+  (= module-name-str (.replace (str module-name) "-" "_"))
+  (= is-relative (.startswith module-name-str "."))
+  (= import-call (ife is-relative
+                      `(importlib.import-module ~module-name-str :package __package__)
+                      `(importlib.import-module ~module-name-str)))
   (return
     `(do (import importlib)
          (= ___imported-macros
-            (getattr (importlib.import-module
-                       ~(.replace (str module-name) "-" "_"))
+            (getattr ~import-call
                      "__macro_namespace"
                      {}))
          ~(conde (not macro-names)
@@ -47,14 +51,14 @@
 
 (when (== __name__ "__main__")
   (import os.path as osp)
-  (from lispy.tools [l2py-f])
+  (from lispy.tools [l2py-s])
 
   (= path (osp.abspath __file__))
 
   (with [(open path "r") as f]
     (= org (f.read)))
 
-  (= translated (l2py-f org))
+  (= translated (l2py-s org :no-lispy True))
 
   (with [(open (-> path
                    (osp.dirname)

{lispython-0.3.0 → 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.0 → lispython-0.3.2}/src/lispy/tools.lpy

@@ -20,14 +20,16 @@
 (from lispy.core.parser [parse])
 (from lispy.core.macro [macroexpand-then-compile])
 
-(def detect-package-name []
-  "Detect package name from current directory by checking for __init__.py"
-  (= cwd (os.getcwd))
-  (if (not (osp.exists (osp.join cwd "__init__.py")))
+(def detect-package-name [:path None]
+  "Detect package name from directory by checking for __init__.py"
+  (= dir-path (ife (is path None)
+                   (os.getcwd)
+                   (osp.dirname (osp.abspath path))))
+  (if (not (osp.exists (osp.join dir-path "__init__.py")))
       (return ""))
   ;; Walk up to find package root
   (= parts [])
-  (= current cwd)
+  (= current dir-path)
   (while (osp.exists (osp.join current "__init__.py"))
     (parts.insert 0 (osp.basename current))
     (= parent (osp.dirname current))
@@ -87,18 +89,23 @@
 (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]
+(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__
-                "__package__" ""
+                "__package__" package
                 "__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))
@@ -118,13 +125,14 @@
 
   (with [(open file-path "rb") as f]
     (= src (.decode (f.read) "utf-8")))
-  (return (+ (l2py-s src :include-meta include_meta :fresh-scope True) "\n")))
+  (= pkg (detect-package-name :path file-path))
+  (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)
@@ -170,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.0 → 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.0 → lispython-0.3.2}/uv.lock

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