chemql-python 1.2.0__tar.gz → 1.2.2__tar.gz

{chemql_python-1.2.0/src/chemql_python.egg-info → chemql_python-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.2.0
+Version: 1.2.2
 Summary: A chemistry-focused query language and REPL
 Author-email: Mohammad Rakibul Islam <rakibulofficial1017@gmail.com>
 Requires-Python: >=3.10
@@ -17,15 +17,15 @@ Dynamic: license-file
 shell commands in one interactive environment.**
 
 ChemQL is a command-line chemistry query language for exploring chemical
-elements, molecules, and reactions. Version 1.2.0 combines database-style
+elements, molecules, and reactions. Version 1.2.2 combines database-style
 chemistry queries, reaction tools, Python interoperability, reusable functions
 and macros, and a persistent shell in one scriptable environment. It combines a small SQL-inspired
 query syntax with a persistent Python environment, reaction utilities,
 optional external molecule lookup, and tools for running repeatable
 scripts.
 
-> **Version covered by this README:** 1.2.0\
-> The examples below describe the ChemQL 1.2.0 source. Dataset
+> **Version covered by this README:** 1.2.2\
+> The examples below describe the ChemQL 1.2.2 source. Dataset
 > contents and external-service availability can affect individual
 > lookup results.
 
@@ -538,7 +538,7 @@ queried or inspected from Python.
 
 ## Preprocessor, functions, and macros
 
-ChemQL 1.2.0 adds three ways to reuse values and logic. These declarations
+ChemQL 1.2.2 adds three ways to reuse values and logic. These declarations
 are processed in source order: definitions affect later lines, not earlier
 ones. They persist during the current ChemQL process/session; they are not
 saved automatically between separate launches.
@@ -833,7 +833,7 @@ redirect a file into the command.
 ``` bash
 chemql --version
 chemql --upgrade
-chemql --upgrade 1.2.0
+chemql --upgrade 1.2.2
 ```
 
 `--upgrade` installs the latest published `chemql-python` release; supplying a

{chemql_python-1.2.0 → chemql_python-1.2.2}/README.md

@@ -4,15 +4,15 @@
 shell commands in one interactive environment.**
 
 ChemQL is a command-line chemistry query language for exploring chemical
-elements, molecules, and reactions. Version 1.2.0 combines database-style
+elements, molecules, and reactions. Version 1.2.2 combines database-style
 chemistry queries, reaction tools, Python interoperability, reusable functions
 and macros, and a persistent shell in one scriptable environment. It combines a small SQL-inspired
 query syntax with a persistent Python environment, reaction utilities,
 optional external molecule lookup, and tools for running repeatable
 scripts.
 
-> **Version covered by this README:** 1.2.0\
-> The examples below describe the ChemQL 1.2.0 source. Dataset
+> **Version covered by this README:** 1.2.2\
+> The examples below describe the ChemQL 1.2.2 source. Dataset
 > contents and external-service availability can affect individual
 > lookup results.
 
@@ -525,7 +525,7 @@ queried or inspected from Python.
 
 ## Preprocessor, functions, and macros
 
-ChemQL 1.2.0 adds three ways to reuse values and logic. These declarations
+ChemQL 1.2.2 adds three ways to reuse values and logic. These declarations
 are processed in source order: definitions affect later lines, not earlier
 ones. They persist during the current ChemQL process/session; they are not
 saved automatically between separate launches.
@@ -820,7 +820,7 @@ redirect a file into the command.
 ``` bash
 chemql --version
 chemql --upgrade
-chemql --upgrade 1.2.0
+chemql --upgrade 1.2.2
 ```
 
 `--upgrade` installs the latest published `chemql-python` release; supplying a

{chemql_python-1.2.0 → chemql_python-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chemql-python"
-version = "1.2.0"
+version = "1.2.2"
 authors = [
     { name = "Mohammad Rakibul Islam", email = "rakibulofficial1017@gmail.com" }
 ]

{chemql_python-1.2.0 → chemql_python-1.2.2}/src/chemql/__init__.py

@@ -18,6 +18,8 @@ from prompt_toolkit.lexers import Lexer
 import atexit
 import uuid
 import select
+import queue
+import threading
 from prompt_toolkit.styles import Style
 from prompt_toolkit.completion import Completer, Completion
 import urllib.parse
@@ -45,7 +47,7 @@ __all__ = [
     "__version__"
 ]
 
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 
 # Persistent preprocessor/function state for the current ChemQL session.
 DEFINITIONS = {}
@@ -107,16 +109,18 @@ def _split_function_arguments(source):
     return args
 
 def _call_function(name, arguments):
-    """Call a ChemQL function; arguments are evaluated Python expressions."""
+    """Call a ChemQL function, including `let` assignments and block syntax."""
     if name not in FUNCTIONS:
         raise NameError(f"Unknown ChemQL function `{name}`")
+
     values = [evaluate_python(arg) for arg in arguments]
     definition = FUNCTIONS[name]
     saved_globals = python_globals.copy()
     saved_chemql_variables = CHEMQL_VARIABLES.copy()
     had_arguments = "arguments" in python_globals
     saved_arguments = python_globals.get("arguments")
-    python_globals["arguments"] = [name, *values]
+    # `arguments` contains only the supplied arguments, not the function name.
+    python_globals["arguments"] = list(values)
 
     def substitute_parameters(source):
         # Replace positional placeholders as tokens, so \1 does not corrupt \10.
@@ -127,6 +131,23 @@ def _call_function(name, arguments):
             source,
         )
 
+    def normalize_let_line(source):
+        """Translate `let name = expression` to a Python assignment block."""
+        match = re.fullmatch(r"\s*let\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*", source)
+        if not match:
+            return source
+        variable, expression = match.groups()
+        expression = substitute_parameters(expression)
+        # In ChemQL function expressions, [i] means evaluate i, rather than
+        # create a Python list containing i. Keep this deliberately simple and
+        # avoid changing arbitrary Python list literals.
+        expression = re.sub(
+            r"\[\s*([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s*\]",
+            r"(\1)",
+            expression,
+        )
+        return f"[{variable} = {expression}]"
+
     try:
         body = definition["body"]
         i = 0
@@ -149,6 +170,29 @@ def _call_function(name, arguments):
                 i += 1
                 continue
 
+            # Support ChemQL's [for ...], [if ...], and [while ...] blocks
+            # inside functions, using the same block executors as the REPL.
+            if is_python_block_header(line):
+                end = find_endblock(body, i + 1)
+                block_body = [
+                    normalize_let_line(substitute_parameters(source_line))
+                    for source_line in body[i + 1:end]
+                ]
+                code = line[1:-1].strip()
+                if code.startswith("for "):
+                    execute_for_block(line, block_body)
+                elif code.startswith("while "):
+                    execute_while_block(line, block_body)
+                elif code.startswith("if "):
+                    execute_if_block(line, block_body)
+                else:
+                    raise SyntaxError(f"Unsupported function block `{code}`")
+                i = end + 1
+                continue
+
+            if line == "[endblock]":
+                raise SyntaxError(f"Unexpected `[endblock]` in function `{name}`")
+
             if line.startswith("return"):
                 expression = line[len("return"):].strip()
                 if expression.startswith("[") and expression.endswith("]"):
@@ -156,7 +200,12 @@ def _call_function(name, arguments):
                 expression = substitute_parameters(expression)
                 return evaluate_python(expression) if expression else None
 
-            evaluate_python(substitute_parameters(line))
+            normalized = normalize_let_line(line)
+            if normalized != line:
+                # The wrapper is ChemQL syntax; pass the assignment itself to Python.
+                evaluate_python(normalized[1:-1])
+            else:
+                evaluate_python(substitute_parameters(line))
             i += 1
         return None
     finally:
@@ -211,17 +260,15 @@ _shell_process = None
 _shell_master_fd = None
 _shell_prompt_ready = False
 _shell_output_streamed = False
+_shell_output_queue = None
+_shell_reader_thread = None
 _shell_prompt = f"__CHEMQL_PROMPT_{uuid.uuid4().hex}__"
 
 
 def get_shell():
-    """Return the persistent shell process.
-
-    On POSIX, use a pseudo-terminal so foreground commands such as `read`,
-    `read -p`, and interactive CLIs can receive keyboard input. Windows keeps
-    the pipe-based implementation until a ConPTY backend is added.
-    """
+    """Return the persistent OS shell process for the current platform."""
     global _shell_process, _shell_master_fd, _shell_prompt_ready
+    global _shell_output_queue, _shell_reader_thread
 
     if _shell_process is not None and _shell_process.poll() is None:
         return _shell_process
@@ -230,14 +277,38 @@ def get_shell():
     close_shell()
 
     if os.name == "nt":
+        # Use PowerShell as ChemQL's native Windows shell. Its prompt function
+        # emits a private marker when a command finishes, so we do not append a
+        # marker to stdin (which would accidentally become Read-Host input).
+        setup = (
+            f"function global:prompt {{ [Console]::Out.WriteLine('{_shell_prompt}'); return '' }}"
+        )
         _shell_process = subprocess.Popen(
-            ["cmd.exe", "/D", "/Q", "/K", "prompt $S"],
+            ["powershell.exe", "-NoLogo", "-NoProfile", "-NoExit", "-Command", setup],
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
             bufsize=1,
         )
+        output_queue = queue.Queue()
+        _shell_output_queue = output_queue
+        process = _shell_process
+
+        def read_output():
+            try:
+                while True:
+                    character = process.stdout.read(1)  # type: ignore
+                    if not character:
+                        break
+                    output_queue.put(character)
+            except (OSError, ValueError):
+                pass
+            finally:
+                output_queue.put(None)
+
+        _shell_reader_thread = threading.Thread(target=read_output, daemon=True)
+        _shell_reader_thread.start()
     else:
         import fcntl
         import pty
@@ -387,47 +458,128 @@ def _run_shell_command_posix(command, marker=None):
         return f"Shell error: {exc}"
 
 
-def run_shell_command(command):
+def _run_shell_command_windows(command):
+    """Run a command in persistent PowerShell and forward line input interactively."""
+    global _shell_prompt_ready, _shell_output_streamed
     shell = get_shell()
-    command = command.replace("\r\n", "\n").replace("\r", "\n").rstrip("\n")
-    marker = f"__CHEMQL_END_{uuid.uuid4().hex}__"
+    output_queue = _shell_output_queue
+    if output_queue is None:
+        return "Shell error: PowerShell output reader was not initialized."
 
-    try:
-        if os.name != "nt":
-            return _run_shell_command_posix(command, marker)
+    import msvcrt
+
+    def wait_for_prompt(stream_output):
+        collected = ""
+        streamed_pos = 0
+        marker = _shell_prompt
+        marker_len = len(marker)
+        stdin_is_tty = False
+        try:
+            stdin_is_tty = sys.stdin is not None and sys.stdin.isatty()
+        except (AttributeError, OSError, ValueError):
+            pass
+        pending_input = ""
 
-        # Windows pipe mode supports persistent commands, but not fully
-        # interactive programs yet; a ConPTY backend is needed for that.
-        shell.stdin.write(command + "\r\n" + f"echo {marker}\r\n")  # type: ignore
-        shell.stdin.flush()  # type: ignore
-        output = []
         while True:
+            # While a shell command is running, pass complete lines typed by the
+            # user to PowerShell. This lets Read-Host receive real input rather
+            # than consuming a completion marker injected by ChemQL.
+            if stdin_is_tty:
+                try:
+                    while msvcrt.kbhit(): #type:ignore
+                        key = msvcrt.getwch()  #type:ignore
+                        if key in ("\x00", "\xe0"):  #type:ignore
+                            # Consume the second half of a Windows special key.
+                            if msvcrt.kbhit():  #type:ignore
+                                msvcrt.getwch()  #type:ignore
+                        elif key in ("\r", "\n"):
+                            shell.stdin.write(pending_input + "\r\n")  # type: ignore
+                            shell.stdin.flush()  # type: ignore
+                            pending_input = ""
+                        elif key == "\b":
+                            pending_input = pending_input[:-1]
+                        elif key == "\x03":
+                            # Ctrl-C is sent as a line input; reset is safer than
+                            # leaving ChemQL stuck in a nested interactive prompt.
+                            close_shell()
+                            return None
+                        elif key >= " " and key != "\x7f":
+                            pending_input += key
+                except (OSError, ValueError):
+                    stdin_is_tty = False
+
             try:
-                line = shell.stdout.readline()  # type: ignore
-            except KeyboardInterrupt:
-                # Avoid leaking a traceback; reset the shell so the next command
-                # starts with a clean process if the current one was interrupted.
-                close_shell()
-                return "Shell command interrupted. Shell session was reset."
-            if not line:
-                return "\n".join(output) or "Shell session terminated."
-            line = line.rstrip("\r\n")
-            if marker in line:
-                break
-            output.append(line)
-        return "\n".join(output).strip()
+                character = output_queue.get(timeout=0.04)
+            except queue.Empty:
+                continue
+            if character is None:
+                return None
+
+            collected += character
+            marker_pos = collected.find(marker)
+            if marker_pos >= 0:
+                visible = collected[:marker_pos]
+                if stream_output and marker_pos > streamed_pos:
+                    sys.stdout.write(collected[streamed_pos:marker_pos])
+                    sys.stdout.flush()
+                    _shell_output_streamed = True
+                return visible.replace("\r\n", "\n").rstrip("\r\n ")
+
+            if stream_output:
+                # Stream immediately, retaining the full output for history and
+                # only withholding a suffix that could begin the prompt marker.
+                overlap = 0
+                max_overlap = min(marker_len - 1, len(collected))
+                for size in range(max_overlap, 0, -1):
+                    if collected.endswith(marker[:size]):
+                        overlap = size
+                        break
+                safe_end = len(collected) - overlap
+                if safe_end > streamed_pos:
+                    sys.stdout.write(collected[streamed_pos:safe_end])
+                    sys.stdout.flush()
+                    _shell_output_streamed = True
+                    streamed_pos = safe_end
+
+    if not _shell_prompt_ready:
+        initial = wait_for_prompt(stream_output=False)
+        if initial is None:
+            close_shell()
+            return "Shell session terminated."
+        _shell_prompt_ready = True
+
+    try:
+        shell.stdin.write(command.replace("\n", "\r\n") + "\r\n")  # type: ignore
+        shell.stdin.flush()  # type: ignore
+        result = wait_for_prompt(stream_output=True)
+        if result is None:
+            close_shell()
+            return "Shell session terminated."
+        return result
+    except (BrokenPipeError, OSError, ValueError) as exc:
+        close_shell()
+        return f"Shell error: {exc}"
+
 
+def run_shell_command(command):
+    global _shell_output_streamed
+    command = command.replace("\r\n", "\n").replace("\r", "\n").rstrip("\n")
+    try:
+        if os.name == "nt":
+            if command.strip().casefold() in {"powershell", "powershell.exe", "pwsh", "pwsh.exe"}:
+                return "ChemQL already uses PowerShell on Windows; run the command directly instead of starting a nested shell."
+            _shell_output_streamed = False
+            return _run_shell_command_windows(command)
+        return _run_shell_command_posix(command)
     except KeyboardInterrupt:
         close_shell()
         return "Shell command interrupted. Shell session was reset."
-    except (BrokenPipeError, OSError) as exc:
-        close_shell()
-        return f"Shell error: {exc}"
 
 
 def close_shell():
     """Clean up the persistent shell and its pseudo-terminal on exit."""
     global _shell_process, _shell_master_fd, _shell_prompt_ready
+    global _shell_output_queue, _shell_reader_thread
 
     if _shell_process is not None:
         if _shell_process.poll() is None:
@@ -449,6 +601,8 @@ def close_shell():
             pass
         _shell_master_fd = None
     _shell_prompt_ready = False
+    _shell_output_queue = None
+    _shell_reader_thread = None
 
 
 atexit.register(close_shell)
@@ -2719,6 +2873,14 @@ def process_lines(lines):
                 print("No definitions.")
             i += 1
             continue
+        if stripped.casefold() == "macros":
+            if MACROS:
+                for name, value in MACROS.items():
+                    print(f"@{name} = {value}")
+            else:
+                print("No macros.")
+            i += 1
+            continue
 
         # Function definitions use `func NAME ... endfunc`.
         function_match = re.fullmatch(r"func\s+(" + _DEFINITION_NAME + r")", stripped, re.IGNORECASE)
@@ -3167,6 +3329,13 @@ def execute(arguments, query_text=None, positions=None):
 
     if arguments[0].lower() == "version":
         return __version__
+    if arguments[0].lower() == "exit":
+        return sys.exit(0)
+    if arguments[0].lower() == "definitions":
+        return "\n".join([f"@{name} = {value}" for name, value in DEFINITIONS.items()]) if DEFINITIONS else "No definitions."
+        
+    if arguments[0].lower() == "macros":
+        return "\n".join([f"@{name} = {value}" for name, value in MACROS.items()]) if MACROS else "No macros."
     
     if arguments[0] == "conditions":
         if len(arguments) != 1:
@@ -3522,6 +3691,7 @@ class ChemqlLexer(Lexer):
         "findmol", "findre", "set", "add", "remove", "react",
         "balance", "conditions", "view", "help", "dump", "version",
         "return", "union", "intersection", "let", "unset", "variables",
+        "macros", "definitions", "arguments",
     }
 
     OPERATORS = {
@@ -3736,7 +3906,7 @@ class ChemqlCompleter(Completer):
         "findel", "findmol", "findre", "set", "add", "remove",
         "react", "balance", "conditions", "version", "help", "view",
         "dump", "let", "unset", "variables", "func", "define",
-        "import",
+        "import", "definitions", "macros",
     )
 
     QUERY_OPERATORS = [

{chemql_python-1.2.0 → chemql_python-1.2.2/src/chemql_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.2.0
+Version: 1.2.2
 Summary: A chemistry-focused query language and REPL
 Author-email: Mohammad Rakibul Islam <rakibulofficial1017@gmail.com>
 Requires-Python: >=3.10
@@ -17,15 +17,15 @@ Dynamic: license-file
 shell commands in one interactive environment.**
 
 ChemQL is a command-line chemistry query language for exploring chemical
-elements, molecules, and reactions. Version 1.2.0 combines database-style
+elements, molecules, and reactions. Version 1.2.2 combines database-style
 chemistry queries, reaction tools, Python interoperability, reusable functions
 and macros, and a persistent shell in one scriptable environment. It combines a small SQL-inspired
 query syntax with a persistent Python environment, reaction utilities,
 optional external molecule lookup, and tools for running repeatable
 scripts.
 
-> **Version covered by this README:** 1.2.0\
-> The examples below describe the ChemQL 1.2.0 source. Dataset
+> **Version covered by this README:** 1.2.2\
+> The examples below describe the ChemQL 1.2.2 source. Dataset
 > contents and external-service availability can affect individual
 > lookup results.
 
@@ -538,7 +538,7 @@ queried or inspected from Python.
 
 ## Preprocessor, functions, and macros
 
-ChemQL 1.2.0 adds three ways to reuse values and logic. These declarations
+ChemQL 1.2.2 adds three ways to reuse values and logic. These declarations
 are processed in source order: definitions affect later lines, not earlier
 ones. They persist during the current ChemQL process/session; they are not
 saved automatically between separate launches.
@@ -833,7 +833,7 @@ redirect a file into the command.
 ``` bash
 chemql --version
 chemql --upgrade
-chemql --upgrade 1.2.0
+chemql --upgrade 1.2.2
 ```
 
 `--upgrade` installs the latest published `chemql-python` release; supplying a