chemql-python 1.3.0__tar.gz → 1.3.2__tar.gz

{chemql_python-1.3.0/src/chemql_python.egg-info → chemql_python-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.3.0
+Version: 1.3.2
 Summary: A chemistry-focused query language and REPL
 Author-email: Mohammad Rakibul Islam <rakibulofficial1017@gmail.com>
 Requires-Python: >=3.10
@@ -19,7 +19,7 @@ SQL-inspired syntax, inspect elements and molecules, look up reactions,
 balance equations, and combine chemistry queries with Python and shell
 commands.
 
--   **Version:** `1.3.0`
+-   **Version:** `1.3.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam

{chemql_python-1.3.0 → chemql_python-1.3.2}/README.md

@@ -6,7 +6,7 @@ SQL-inspired syntax, inspect elements and molecules, look up reactions,
 balance equations, and combine chemistry queries with Python and shell
 commands.
 
--   **Version:** `1.3.0`
+-   **Version:** `1.3.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam

{chemql_python-1.3.0 → chemql_python-1.3.2}/pyproject.toml

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

{chemql_python-1.3.0 → chemql_python-1.3.2}/src/chemql/__init__.py

@@ -52,7 +52,7 @@ __all__ = [
     "__version__"
 ]
 
-__version__ = "1.3.0"
+__version__ = "1.3.2"
 
 # Persistent preprocessor/function state for the current ChemQL session.
 DEFINITIONS = {}
@@ -61,6 +61,7 @@ MACROS = {}
 EXECUTION_HISTORY = []
 _DEFINITION_NAME = r"[A-Za-z_][A-Za-z0-9_]*"
 _NO_RETURN = object()
+NO_ANSI = True
 
 def _expand_definitions(line):
     """Replace @NAME literally, including inside strings, using current definitions."""
@@ -993,10 +994,11 @@ _CHEMQL_RISK_DEPTH = 0
 
 
 def format_error(message, text=None, position=None, length=1):
-    output = f"Error: {message}"
+    output = ""
+    if (text is not None) and (position is not None) and (not NO_ANSI):
+        output += f"\033[1;31m{' ' * (position+4)}{'^' * max(1, length)}\n\033[0m"
+    output += f"Error: {message}" if NO_ANSI else f"\033[31mError: {message}\033[0m"
 
-    if text is not None and position is not None:
-        output += f"\n{text}\n{' ' * position}{'^' * max(1, length)}"
 
     return output
 
@@ -2034,7 +2036,7 @@ def _reaction_api_json(url, timeout=REACTION_API_TIMEOUT):
     request = urllib.request.Request(
         url,
         headers={
-            "User-Agent": "ChemQL/1.3.0 (reaction lookup; contact: chemql-user)",
+            "User-Agent": f"ChemQL/{__version__} (reaction lookup; contact: chemql-user)",
             "Accept": "application/json",
         },
     )
@@ -2050,7 +2052,7 @@ def _reaction_api_text(url, timeout=REACTION_API_TIMEOUT):
     request = urllib.request.Request(
         url,
         headers={
-            "User-Agent": "ChemQL/1.3.0 (reaction lookup; contact: chemql-user)",
+            "User-Agent": f"ChemQL/{__version__} (reaction lookup; contact: chemql-user)",
             "Accept": "text/tab-separated-values,text/plain,*/*",
         },
     )
@@ -2293,40 +2295,40 @@ def _formula_counts(formula):
             if char == "(":
                 group, index = parse_group(index + 1, True)
                 if index >= len(formula) or formula[index] != ")":
-                    raise ValueError(f"Unclosed parenthesis in formula `{formula}`")
+                    raise ValueError((f"Unclosed parenthesis in formula `{formula}`" if NO_ANSI else f"Unclosed parenthesis in formula \033[1m{formula}\033[22m"))
                 index += 1
                 match = re.match(r"\d+", formula[index:])
                 multiplier = int(match.group()) if match else 1
                 if multiplier <= 0:
-                    raise ValueError(f"Invalid atom count in formula `{formula}`")
+                    raise ValueError((f"Invalid atom count in formula `{formula}`" if NO_ANSI else f"Invalid atom count in formula \033[1m{formula}\033[22m"))
                 if match:
                     index += len(match.group())
                 for symbol, amount in group.items():
                     counts[symbol] = counts.get(symbol, 0) + amount * multiplier
                 continue
             if not char.isupper():
-                raise ValueError(f"Invalid chemical formula `{formula}`")
+                raise ValueError((f"Invalid chemical formula `{formula}`" if NO_ANSI else f"Invalid chemical formula \033[1m{formula}\033[22m"))
             end = index + 1
             if end < len(formula) and formula[end].islower():
                 end += 1
             symbol = formula[index:end]
             if symbol not in symbols:
-                raise ValueError(f"Unknown element `{symbol}` in formula `{formula}`")
+                raise ValueError((f"Unknown element `{symbol}` in formula `{formula}`" if NO_ANSI else f"Unknown element `{symbol}` in formula \033[1m{formula}\033[22m"))
             index = end
             match = re.match(r"\d+", formula[index:])
             amount = int(match.group()) if match else 1
             if amount <= 0:
-                raise ValueError(f"Invalid atom count in formula `{formula}`")
+                raise ValueError((f"Invalid atom count in formula `{formula}`" if NO_ANSI else f"Invalid atom count in formula \033[1m{formula}\033[22m"))
             if match:
                 index += len(match.group())
             counts[symbol] = counts.get(symbol, 0) + amount
         if nested:
-            raise ValueError(f"Unclosed parenthesis in formula `{formula}`")
+            raise ValueError((f"Unclosed parenthesis in formula `{formula}`" if NO_ANSI else f"Unclosed parenthesis in formula \033[1m{formula}\033[22m"))
         return counts, index
 
     counts, end = parse_group(0)
     if end != len(formula) or not counts:
-        raise ValueError(f"Invalid chemical formula `{formula}`")
+        raise ValueError((f"Invalid chemical formula `{formula}`" if NO_ANSI else f"Invalid chemical formula \033[1m{formula}\033[22m"))
     return counts
 
 
@@ -2455,7 +2457,7 @@ def queryElement(key, func, value, *params):
 
 def queryElementLast(key, func, value, *params):
     if key not in elementKeys:
-        raise KeyError(f"There is no key `{key}`")
+        raise KeyError((f"There is no key `{key}`" if NO_ANSI else f"There is no key \033[1m{key}\033[22m"))
 
     for element in reversed(ELEMENTS):
         if getattr(element[key], func)(value, *params):
@@ -2466,7 +2468,7 @@ def queryElementLast(key, func, value, *params):
 
 def queryElementAll(key, func, value, *params):
     if key not in elementKeys:
-        raise KeyError(f"There is no key `{key}`")
+        raise KeyError((f"There is no key `{key}`" if NO_ANSI else f"There is no key \033[1m{key}\033[22m"))
 
     found = False
 
@@ -2527,7 +2529,7 @@ def sort_results(results, key, descending=False):
             reverse=descending
         )
     except (TypeError, AttributeError):
-        raise ValueError(f"Cannot sort by `{key}`")
+        raise ValueError((f"Cannot sort by `{key}`" if NO_ANSI else f"Cannot sort by \033[1m{key}\033[22m"))
 
 def apply_query_operations(results, tokens, keys, positions=None):
     i = 0
@@ -2538,13 +2540,13 @@ def apply_query_operations(results, tokens, keys, positions=None):
         # sort
         if token == "sort":
             if i + 1 >= len(tokens):
-                raise ChemQLError("Expected a key after `sort`", *(error_position(positions, i) if positions else (None, 1))) #type:ignore
+                raise ChemQLError(("Expected a key after `sort`" if NO_ANSI else "Expected a key after \033[1msort\033[22m"), *(error_position(positions, i) if positions else (None, 1))) #type:ignore
 
             key = tokens[i + 1]
 
             if key not in keys:
                 pos, length = error_position(positions, i + 1) if positions else (None, 1)
-                raise ChemQLError(f"There is no key `{key}`", pos, length)
+                raise ChemQLError((f"There is no key `{key}`" if NO_ANSI else f"There is no key \033[1m{key}\033[22m"), pos, length)
 
             descending = False
 
@@ -2573,17 +2575,17 @@ def apply_query_operations(results, tokens, keys, positions=None):
         # limit
         elif token == "limit":
             if i + 1 >= len(tokens):
-                raise ChemQLError("Expected a number after `limit`", *(error_position(positions, i) if positions else (None, 1)))#type:ignore
+                raise ChemQLError(("Expected a number after `limit`" if NO_ANSI else "Expected a number after \033[1mlimit\033[22m"), *(error_position(positions, i) if positions else (None, 1)))#type:ignore
 
             try:
                 amount = int(tokens[i + 1])
             except ValueError:
                 pos, length = error_position(positions, i + 1) if positions else (None, 1)
-                raise ChemQLError("`limit` requires an integer", pos, length)
+                raise ChemQLError(("`limit` requires an integer" if NO_ANSI else "\033[1mlimit\033[22m requires an integer"), pos, length)
 
             if amount < 0:
                 pos, length = error_position(positions, i + 1) if positions else (None, 1)
-                raise ChemQLError("`limit` cannot be negative", pos, length)
+                raise ChemQLError(("`limit` cannot be negative" if NO_ANSI else "\033[1mlimit\033[22m cannot be negative"), pos, length)
 
             results = results[:amount] # type: ignore
 
@@ -2593,14 +2595,14 @@ def apply_query_operations(results, tokens, keys, positions=None):
         elif token == "count":
             if i + 1 < len(tokens):
                 pos, length = error_position(positions, i) if positions else (None, 1)
-                raise ChemQLError("`count` must be the final query operation", pos, length)
+                raise ChemQLError(("`count` must be the final query operation" if NO_ANSI else "\033[1mcount\033[22m must be the final query operation"), pos, length)
 
             results = len(results) # type: ignore
             i += 1
 
         else:
             pos, length = error_position(positions, i) if positions else (None, 1)
-            raise ChemQLError(f"Unknown query operation `{token}`", pos, length)
+            raise ChemQLError((f"Unknown query operation `{token}`" if NO_ANSI else f"Unknown query operation \033[1m{token}\033[22m"), pos, length)
 
     return results
 
@@ -2619,7 +2621,7 @@ def convert_value(value, sample):
         if value.lower() == "false":
             return False
 
-        raise ValueError(f"`{value}` is not a boolean")
+        raise ValueError((f"`{value}` is not a boolean" if NO_ANSI else f"\033[1m{value}\033[22m is not a boolean"))
 
     if isinstance(sample, (int, float)):
 
@@ -2632,7 +2634,7 @@ def convert_value(value, sample):
             return number
 
         except ValueError:
-            raise ValueError(f"`{value}` is not a number")
+            raise ValueError((f"`{value}` is not a number" if NO_ANSI else f"\033[1m{value}\033[22m is not a number"))
 
     return value
 
@@ -2652,7 +2654,7 @@ def parse_condition(tokens, index, source, keys, positions=None):
     negated = operator.casefold() == "not"
     if negated:
         if index + 3 >= len(tokens):
-            raise ChemQLError("Expected an operator and value after `not`", *(error_position(positions, index + 1) if positions else (None, 1)))  # type: ignore
+            raise ChemQLError(("Expected an operator and value after `not`" if NO_ANSI else "Expected an operator and value after \033[1mnot\033[22m"), *(error_position(positions, index + 1) if positions else (None, 1)))  # type: ignore
         operator = tokens[index + 2]
         value = tokens[index + 3]
         consumed = index + 4
@@ -2662,7 +2664,7 @@ def parse_condition(tokens, index, source, keys, positions=None):
 
     if key not in keys:
         pos, length = error_position(positions, index) if positions else (None, 1)
-        raise ChemQLError(f"There is no key `{key}`", pos, length)
+        raise ChemQLError((f"There is no key `{key}`" if NO_ANSI else f"There is no key \033[1m{key}\033[22m"), pos, length)
 
     if operator in {"like", "like!", "likep"}:
         pattern = value
@@ -2737,7 +2739,7 @@ def parse_condition(tokens, index, source, keys, positions=None):
 
     if operator not in functionMap:
         pos, length = error_position(positions, index + 1) if positions else (None, 1)
-        raise ChemQLError(f"Unknown operator `{operator}`", pos, length)
+        raise ChemQLError((f"Unknown operator `{operator}`" if NO_ANSI else f"Unknown operator \033[1m{operator}\033[22m"), pos, length)
 
     sample = getattr(source[0], key)
 
@@ -2779,7 +2781,7 @@ def parse_primary(tokens, index, source, keys, positions=None):
 
         if index >= len(tokens) or tokens[index] != ")":
             pos = positions[index][0] if positions and index < len(positions) else None
-            raise ChemQLError("Missing `)`", pos)
+            raise ChemQLError(("Missing `)`" if NO_ANSI else "Missing \033[1m)\033[22m"), pos)
 
         return expression, index + 1
 
@@ -2867,7 +2869,7 @@ def parse_query(tokens, source, keys, positions=None):
     if index < len(tokens) and tokens[index] not in queryOperations:
         pos, length = error_position(positions, index) if positions else (None, 1)
         raise ChemQLError(
-            f"Unexpected `{tokens[index]}`", pos, length
+            (f"Unexpected `{tokens[index]}`" if NO_ANSI else f"Unexpected \033[1m{tokens[index]}\033[22m"), pos, length
         )
 
     return condition, index
@@ -2950,7 +2952,7 @@ def find_matching(text, start, opening, closing):
 
         i += 1
 
-    raise SyntaxError(f"Missing `{closing}`")
+    raise SyntaxError((f"Missing `{closing}`" if NO_ANSI else f"Missing \033[1m{closing}\033[22m"))
 
 
 def interpolate_query(text):
@@ -3273,7 +3275,7 @@ def find_endblock(lines, start):
         # expand to a ChemQL struct representation that is not Python syntax.
         if re.match(r"^\[\s*(?:if|for|while)\b", stripped):
             depth += 1
-    raise SyntaxError("Missing block terminator (`endblock`, `endfor`, `endwhile`, or `endif`)")
+    raise SyntaxError(("Missing block terminator (`endblock`, `endfor`, `endwhile`, or `endif`)" if NO_ANSI else "Missing block terminator (\033[1mendblock\033[22m, \033[1mendfor\033[22m, \033[1mendwhile\033[22m, or \033[1mendif\033[22m)"))
 
 
 def remove_comments(line):
@@ -3319,7 +3321,7 @@ def execute_for_block(header, body):
     node = tree.body[0]
 
     if not isinstance(node, ast.For):
-        raise SyntaxError("Expected a `for` block")
+        raise SyntaxError(("Expected a `for` block" if NO_ANSI else "Expected a \033[1mfor\033[22m block"))
 
     iterable = eval(
         compile(ast.Expression(node.iter), "<embedded-python>", "eval"),
@@ -3378,7 +3380,7 @@ def execute_while_block(header, body):
     node = tree.body[0]
 
     if not isinstance(node, ast.While):
-        raise SyntaxError("Expected a `while` block")
+        raise SyntaxError(("Expected a `while` block" if NO_ANSI else "Expected a \033[1mwhile\033[22m block"))
 
     while eval(
         compile(
@@ -3456,7 +3458,7 @@ def execute_if_block(header, body):
 
         else:
             raise SyntaxError(
-                f"Invalid conditional `{code}`"
+                (f"Invalid conditional `{code}`" if NO_ANSI else f"Invalid conditional \033[1m{code}\033[22m")
             )
 
         if evaluate_python(condition):
@@ -3801,7 +3803,7 @@ def process_lines(lines):
             while end < len(lines) and lines[end].strip().casefold() != terminator:
                 end += 1
             if end >= len(lines):
-                raise SyntaxError(f"Missing `{terminator}` for {kind} `{type_name}`")
+                raise SyntaxError((f"Missing `{terminator}` for {kind} `{type_name}`" if NO_ANSI else f"Missing \033[1m{terminator}\033[22m for {kind} \033[1m{type_name}\033[22m"))
             fields, defaults = [], {}
             for field_line in lines[i + 1:end]:
                 field_line = remove_comments(field_line).strip()
@@ -3812,12 +3814,12 @@ def process_lines(lines):
                     raise SyntaxError(f"Invalid {kind} field declaration: {field_line}")
                 field, default = match.groups()
                 if field in fields:
-                    raise SyntaxError(f"Duplicate field `{field}` in {type_name}")
+                    raise SyntaxError((f"Duplicate field `{field}` in {type_name}" if NO_ANSI else f"Duplicate field \033[1m{field}\033[22m in {type_name}"))
                 fields.append(field)
                 if default is not None:
                     defaults[field] = evaluate_python(_expand_definitions(default))
             if not fields:
-                raise SyntaxError(f"{kind.title()} `{type_name}` must declare fields")
+                raise SyntaxError((f"{kind.title()} `{type_name}` must declare fields" if NO_ANSI else f"{kind.title()} \033[1m{type_name}\033[22m must declare fields"))
             if kind == "struct":
                 def make_struct(class_name, field_names, field_defaults):
                     def __init__(self, *args, **kwargs):
@@ -3826,7 +3828,7 @@ def process_lines(lines):
                         values = dict(zip(field_names, args))
                         overlap = values.keys() & kwargs.keys()
                         if overlap:
-                            raise TypeError(f"Multiple values for field `{next(iter(overlap))}`")
+                            raise TypeError((f"Multiple values for field `{next(iter(overlap))}`" if NO_ANSI else f"Multiple values for field \033[1m{next(iter(overlap))}\033[22m"))
                         values.update(kwargs)
                         extra = values.keys() - set(field_names)
                         if extra:
@@ -3844,7 +3846,7 @@ def process_lines(lines):
                 from collections import namedtuple
                 first_default = next((n for n, f in enumerate(fields) if f in defaults), len(fields))
                 if any(f not in defaults for f in fields[first_default:]):
-                    raise SyntaxError(f"Record `{type_name}` fields with defaults must be trailing fields")
+                    raise SyntaxError((f"Record `{type_name}` fields with defaults must be trailing fields" if NO_ANSI else f"Record \033[1m{type_name}\033[22m fields with defaults must be trailing fields"))
                 generated = namedtuple(type_name, fields, defaults=[defaults[f] for f in fields[first_default:]])
                 generated.__str__ = lambda self, _name=type_name: _name + " -> " + ", ".join(f"{f}: {getattr(self, f)}" for f in self._fields)
                 RECORDS[type_name] = generated
@@ -3863,7 +3865,7 @@ def process_lines(lines):
                     if nesting == 0: break
                 end += 1
             if end >= len(lines):
-                raise SyntaxError("Missing `endrisk`")
+                raise SyntaxError(("Missing `endrisk`" if NO_ANSI else "Missing \033[1mendrisk\033[22m"))
             sections = {"risk": [], "fix": [], "cleanup": []}
             section = "risk"
             for risk_line in lines[i + 1:end]:
@@ -3935,13 +3937,13 @@ def process_lines(lines):
             while end < len(lines) and lines[end].strip().casefold() != "endfunc":
                 end += 1
             if end >= len(lines):
-                raise SyntaxError(f"Missing `endfunc` for function `{name}`")
+                raise SyntaxError((f"Missing `endfunc` for function `{name}`" if NO_ANSI else f"Missing `endfunc` for function \033[1m{name}\033[22m"))
             FUNCTIONS[name] = {"body": [_expand_definitions(source_line) for source_line in lines[i + 1:end]]}
             if "." in name:
                 owner_name, method_name = name.split(".", 1)
                 owner = STRUCTS.get(owner_name)
                 if owner is None:
-                    raise NameError(f"Cannot define method `{name}`: struct `{owner_name}` does not exist")
+                    raise NameError((f"Cannot define method `{name}`: struct `{owner_name}` does not exist" if NO_ANSI else f"Cannot define method `{name}`: struct \033[1m{owner_name}\033[22m does not exist"))
                 def _make_struct_method(function_name):
                     def _method(instance, *args):
                         had_this = "this" in python_globals
@@ -3978,7 +3980,7 @@ def process_lines(lines):
             while end < len(lines) and lines[end].strip().casefold() != "enddefine":
                 end += 1
             if end >= len(lines):
-                raise SyntaxError(f"Missing `enddefine` for macro `{name}`")
+                raise SyntaxError((f"Missing `enddefine` for macro `{name}`" if NO_ANSI else f"Missing `enddefine` for macro \033[1m{name}\033[22m"))
             MACROS[name] = [_expand_definitions(source_line) for source_line in lines[i + 1:end]]
             i = end + 1
             continue
@@ -4006,7 +4008,7 @@ def process_lines(lines):
                         break
                     close_line += 1
                 if close_line >= len(lines):
-                    raise SyntaxError("Missing closing `///` for multiline comment")
+                    raise SyntaxError(("Missing closing `///` for multiline comment" if NO_ANSI else "Missing closing \033[1m///\033[22m for multiline comment"))
                 suffix = lines[close_line][close_pos + 3:]
                 lines[i] = prefix
                 del lines[i + 1:close_line + 1]
@@ -4030,7 +4032,7 @@ def process_lines(lines):
                 body.append(lines[i])
                 i += 1
             if i >= len(lines):
-                raise SyntaxError("Missing closing `]]]` for Python block")
+                raise SyntaxError(("Missing closing `]]]` for Python block" if NO_ANSI else "Missing closing \033[1m]]]\033[22m for Python block"))
             body = [_expand_definitions(source_line) for source_line in body]
             code = "\n".join(body)
             captured = io.StringIO()
@@ -4045,7 +4047,7 @@ def process_lines(lines):
                     print(output, end="" if output.endswith("\n") else "\n")
                 _record_execution("[[[\n" + code + "\n]]]", output, True)
             except Exception as exc:
-                message = f"Error: {exc}"
+                message = f"\033[31mError: {exc}\033[0m"
                 print(strip_ansi(message) if NO_ANSI else message, file=sys.stderr)
                 _record_execution("[[[\n" + code + "\n]]]", message, False)
             i += 1
@@ -4059,7 +4061,7 @@ def process_lines(lines):
                 body.append(lines[i])
                 i += 1
             if i >= len(lines):
-                raise SyntaxError("Missing closing ``` for terminal block")
+                raise SyntaxError("Missing closing \033[1m```\033[22m for terminal block")
             body = [_expand_definitions(source_line) for source_line in body]
             command = "\n".join(body)
             result = run_shell_command(command)
@@ -4082,7 +4084,7 @@ def process_lines(lines):
             continue
 
         if line == "[endblock]":
-            raise SyntaxError("Unexpected `[endblock]`")
+            raise SyntaxError(("Unexpected `[endblock]`" if NO_ANSI else "Unexpected \033[1m[endblock]\033[22m"))
 
         # Existing Python control-flow blocks.
         if is_python_block_header(line):
@@ -4096,7 +4098,7 @@ def process_lines(lines):
             elif code.startswith("if "):
                 execute_if_block(line, body)
             else:
-                raise SyntaxError(f"Unsupported block `{code}`")
+                raise SyntaxError((f"Unsupported block `{code}`" if NO_ANSI else f"Unsupported block \033[1m{code}\033[22m"))
             i = end + 1
             continue
 
@@ -4164,7 +4166,7 @@ def process_lines(lines):
             except Exception as exc:
                 if _CHEMQL_RISK_DEPTH:
                     raise
-                message = f"Error: {exc}"
+                message = f"\033[31mError: {exc}\033[0m"
                 print(strip_ansi(message) if NO_ANSI else message, file=sys.stderr)
                 _record_execution(command, message, False)
 
@@ -4194,7 +4196,7 @@ def parse_temperature_setting(value):
 
     match = re.fullmatch(r"([+-]?(?:\d+(?:\.\d*)?|\.\d+))\s*(?:°\s*)?(celsius|fahrenheit|kelvin|degc|degf|degk|c|f|k)", normalized)
     if not match:
-        raise ValueError("Temperature must use C, F, or K, or be `standard` or `room`")
+        raise ValueError(("Temperature must use C, F, or K, or be `standard` or `room`" if NO_ANSI else "Temperature must use C, F, or K, or be \033[1mstandard\033[22m or \033[1mroom\033[22m"))
 
     temperature = float(match.group(1))
     unit = match.group(2)
@@ -4362,7 +4364,7 @@ def react(values):
         molecule = _resolve_reaction_product(product)
         if molecule is None:
             label = product.get("name", product["molecule"])
-            return f"Could not resolve product molecule `{label}` for reaction `{reaction.id}`"
+            return (f"Could not resolve product molecule `{label}` for reaction `{reaction.id}`" if NO_ANSI else f"Could not resolve product molecule \033[1m{label}\033[22m for reaction \033[1m{reaction.id}\033[22m")
         resolved.append((molecule, product["stoichiometric_coefficient"], product.get("phase")))
 
     if len(resolved) == 1:
@@ -4465,7 +4467,7 @@ def execute(arguments, query_text=None, positions=None):
                 return "Catalysts cleared"
             return f"Catalysts set to {', '.join(reaction_state['catalysts'])}"
 
-        return f"Unknown reaction setting `{setting}`"
+        return (f"Unknown reaction setting `{setting}`" if NO_ANSI else f"Unknown reaction setting \033[1m{setting}\033[22m")
 
     if arguments[0] == "add" and len(arguments) >= 2 and arguments[1].lower() == "catalyst":
         if len(arguments) < 3:
@@ -4523,7 +4525,7 @@ def execute(arguments, query_text=None, positions=None):
 
             for attribute in return_attributes:
                 if attribute not in moleculeKeys:
-                    return f"There is no key `{attribute}`"
+                    return (f"There is no key `{attribute}`" if NO_ANSI else f"There is no key \033[1m{attribute}\033[22m")
 
             if return_index != 2:
                 return "Usage: findmol <name-or-formula> [return <attribute> ...]"
@@ -4540,7 +4542,7 @@ def execute(arguments, query_text=None, positions=None):
             result = fetch_pubchem_molecule(value)
 
         if result is None:
-            return f"Could not find molecule `{value}`"
+            return (f"Could not find molecule `{value}`" if NO_ANSI else f"Could not find molecule \033[1m{value}\033[22m")
 
         if isinstance(result, str) and "PubChem is currently unavailable" in result:
             return result
@@ -4576,7 +4578,7 @@ def execute(arguments, query_text=None, positions=None):
 
             for attribute in return_attributes:
                 if attribute not in reactionKeys:
-                    return f"There is no key `{attribute}`"
+                    return (f"There is no key `{attribute}`" if NO_ANSI else f"There is no key \033[1m{attribute}\033[22m")
 
             if return_index != 2:
                 return "Usage: findre <name-or-id> [return <attribute> ...]"
@@ -4594,7 +4596,7 @@ def execute(arguments, query_text=None, positions=None):
         if result == [] or result == "No matching item":
             result = find_reaction(value, external=True)
             if result is None:
-                return f"Could not find reaction `{value}` in Reactions.json, Rhea, or Chempirical"
+                return (f"Could not find reaction `{value}` in Reactions.json, Rhea, or Chempirical" if NO_ANSI else f"Could not find reaction \033[1m{value}\033[22m in Reactions.json, Rhea, or Chempirical")
 
         if return_attributes:
             if isinstance(result, list):
@@ -4621,10 +4623,10 @@ def execute(arguments, query_text=None, positions=None):
         source_name = arguments[1]
 
         if source_name not in SOURCES:
-            return f"There is no source `{source_name}`"
+            return (f"There is no source `{source_name}`" if NO_ANSI else f"There is no source \033[1m{source_name}\033[22m")
 
         current_source = source_name
-        return f"Source set to `{source_name}`"
+        return (f"Source set to `{source_name}`" if NO_ANSI else f"Source set to \033[1m{source_name}\033[22m")
 
     if arguments[0] == "list":
         if len(arguments) != 2 or arguments[1] != "all":
@@ -4660,8 +4662,8 @@ def execute(arguments, query_text=None, positions=None):
         if source_name is None:
             return (
                 "No source selected. "
-                "Specify one, e.g. "
-                "`search all elements atomic_mass < 100`"
+                "Specify one, e.g. "+
+                ("`search all elements atomic_mass < 100`" if NO_ANSI else "\033[1msearch all elements atomic_mass < 100\033[22m")
             )
 
         source, keys = SOURCES[source_name]
@@ -4682,7 +4684,7 @@ def execute(arguments, query_text=None, positions=None):
                     absolute_index = return_index + 1 + attribute_index
                     pos, length = error_position(positions, absolute_index) if positions else (None, 1)
                     return format_error(
-                        f"There is no key `{attribute}`",
+                        (f"There is no key `{attribute}`" if NO_ANSI else f"There is no key \033[1m{attribute}\033[22m"),
                         query_text,
                         pos,
                         length
@@ -4718,9 +4720,9 @@ def execute(arguments, query_text=None, positions=None):
 
         if isinstance(results, int):
             if mode != "all":
-                return format_error("`count` cannot be combined with `first` or `last`")
+                return format_error(("`count` cannot be combined with `first` or `last`" if NO_ANSI else "\033[1mcount\033[22m cannot be combined with \033[1mfirst\033[22m or \033[1mlast\033[22m"))
             if return_attributes is not None:
-                return format_error("`return` cannot be used with `count`")
+                return format_error(("`return` cannot be used with `count`" if NO_ANSI else "\033[1mreturn\033[22m cannot be used with \033[1mcount\033[22m"))
             return results
 
         # `return` is a projection. It intentionally happens after
@@ -4758,15 +4760,183 @@ def execute(arguments, query_text=None, positions=None):
     if query_text is not None and positions:
         pos, length = error_position(positions, 0)
         return format_error(
-            f"Unknown command `{arguments[0]}`",
+            (f"Unknown command `{arguments[0]}`" if NO_ANSI else f"Unknown command \033[1m{arguments[0]}\033[22m"),
             query_text,
             pos,
             length
         )
 
-    return format_error(f"Unknown command `{arguments[0]}`")
+    return format_error((f"Unknown command `{arguments[0]}`" if NO_ANSI else f"Unknown command \033[1m{arguments[0]}\033[22m"))
+
+
+HELP = (
+    "\x1b[1;94m╭──────────────────────────────────────────────────────────────────────────────╮\x1b[0m\n"
+   f"\x1b[1;94m│\x1b[0m  \x1b[1;96m✦ \x1b[1mChemQL\x1b[0m \x1b[97mv{__version__}\x1b[0m    \x1b[90m│\x1b[0m \x1b[1m\x1b[97mTHE PYTHON CHEMISTRY QUERY LANGUAGE\x1b[0m                    \x1b[1;94m│\x1b[0m\n"
+    "\x1b[1;94m│\x1b[0m  \x1b[90mQuery chemistry · automate calculations · build reusable programs\x1b[0m           \x1b[1;94m│\x1b[0m\n"
+    "\x1b[1;94m╰──────────────────────────────────────────────────────────────────────────────╯\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m▶  QUICK START\x1b[0m\n"
+    "  \x1b[92msearch elements ...          \x1b[0m \x1b[90m│\x1b[0m Search the periodic table\n"
+    "  \x1b[92msearch molecules ...         \x1b[0m \x1b[90m│\x1b[0m Search molecule records\n"
+    "  \x1b[92msearch reactions ...         \x1b[0m \x1b[90m│\x1b[0m Search stored reactions\n"
+    "  \x1b[92mfindel \"He\"                  \x1b[0m \x1b[90m│\x1b[0m Find an element\n"
+    "  \x1b[92mfindmol \"Water\"              \x1b[0m \x1b[90m│\x1b[0m Find a molecule\n"
+    "  \x1b[92mfindre \"Haber process\"       \x1b[0m \x1b[90m│\x1b[0m Find a reaction\n"
+    "  \x1b[92mbalance H2 + O2 -> H2O       \x1b[0m \x1b[90m│\x1b[0m Balance a chemical equation\n"
+    "  \x1b[92mhelp  or  ?                  \x1b[0m \x1b[90m│\x1b[0m Display this help message\n"
+    "  \x1b[92mversion                      \x1b[0m \x1b[90m│\x1b[0m Display the installed version\n"
+    "  \x1b[92mexit                         \x1b[0m \x1b[90m│\x1b[0m Exit the interactive prompt\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  CHEMICAL DATA & SEARCH\x1b[0m\n"
+    "  \x1b[1;96msearch elements [conditions]  \x1b[0m      \x1b[90m│\x1b[0m Query element data\n"
+    "  \x1b[1;96msearch molecules [conditions] \x1b[0m      \x1b[90m│\x1b[0m Query molecule data\n"
+    "  \x1b[1;96msearch reactions [conditions] \x1b[0m      \x1b[90m│\x1b[0m Query stored reaction data\n"
+    "  \x1b[1;96msource elements|molecules|reactions\x1b[0m \x1b[90m│\x1b[0m Set the current source\n"
+    "  \x1b[1;96mlist all                      \x1b[0m      \x1b[90m│\x1b[0m List available fields and sources\n"
+    "    \x1b[95msearch elements symbol = \"Fe\" return name symbol number\x1b[0m\n"
+    "    \x1b[95msearch molecules molecular_weight < 50 sort molecular_weight limit 10\x1b[0m\n"
+    "    \x1b[95msearch reactions reversible = true return name equation source\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  FILTERS & LOGIC\x1b[0m\n"
+    "  \x1b[1;96m= != > < >= <=               \x1b[0m \x1b[90m│\x1b[0m Comparison operators\n"
+    "  \x1b[1;96mlike                         \x1b[0m \x1b[90m│\x1b[0m Case-insensitive wildcard match\n"
+    "  \x1b[1;96mlike!                        \x1b[0m \x1b[90m│\x1b[0m Case-sensitive wildcard match\n"
+    "  \x1b[1;96mlikep                        \x1b[0m \x1b[90m│\x1b[0m Pattern-based matching\n"
+    "  \x1b[1;96mhas                          \x1b[0m \x1b[90m│\x1b[0m Check whether a collection contains an item\n"
+    "  \x1b[1;96mand / or                     \x1b[0m \x1b[90m│\x1b[0m Combine conditions\n"
+    "    \x1b[95msearch elements number > 10 and number < 20\x1b[0m\n"
+    "    \x1b[95msearch molecules name like \"*water*\"\x1b[0m\n"
+    "    \x1b[95msearch reactions reactants has \"O2\" and products has \"H2O\"\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  RESULT OPERATIONS\x1b[0m\n"
+    "  \x1b[92mfirst / last                 \x1b[0m \x1b[90m│\x1b[0m Select the first or last result\n"
+    "  \x1b[92msort FIELD [asc|desc]        \x1b[0m \x1b[90m│\x1b[0m Sort matching records\n"
+    "  \x1b[92mlimit N                      \x1b[0m \x1b[90m│\x1b[0m Limit the number of results\n"
+    "  \x1b[92mcount                        \x1b[0m \x1b[90m│\x1b[0m Count matching records\n"
+    "  \x1b[92mreturn FIELD ...             \x1b[0m \x1b[90m│\x1b[0m Choose fields to display\n"
+    "  \x1b[92munion / intersection         \x1b[0m \x1b[90m│\x1b[0m Combine result sets\n"
+    "    \x1b[95msearch molecules molecular_weight < 20 sort molecular_weight asc limit 5\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  REACTIONS & CONDITIONS\x1b[0m\n"
+    "  \x1b[1;96mbalance H2 + O2 -> H2O       \x1b[0m \x1b[90m│\x1b[0m Balance an equation\n"
+    "  \x1b[1;96mbalance N2 + H2 <-> NH3      \x1b[0m \x1b[90m│\x1b[0m Balance a reversible equation\n"
+    "  \x1b[1;96mreact N2 3H2                 \x1b[0m \x1b[90m│\x1b[0m Find a matching stored reaction\n"
+    "  \x1b[1;96mset temperature 150C         \x1b[0m \x1b[90m│\x1b[0m Set the reaction temperature\n"
+    "  \x1b[1;96mset pressure 1atm            \x1b[0m \x1b[90m│\x1b[0m Set the reaction pressure\n"
+    "  \x1b[1;96mset catalysts iron zinc      \x1b[0m \x1b[90m│\x1b[0m Set available catalysts\n"
+    "  \x1b[1;96mset catalysts                \x1b[0m \x1b[90m│\x1b[0m Clear the catalyst list\n"
+    "  \x1b[1;96madd catalyst \"Iron\"        \x1b[0m \x1b[90m│\x1b[0m Add a catalyst\n"
+    "  \x1b[1;96mremove catalyst \"Iron\"     \x1b[0m \x1b[90m│\x1b[0m Remove a catalyst\n"
+    "  \x1b[1;96mconditions                   \x1b[0m \x1b[90m│\x1b[0m Display current conditions\n"
+    "  \x1b[2mTemperature units: K, C, F. Pressure units include Pa, bar, and atm.\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  VARIABLES & DEFINITIONS\x1b[0m\n"
+    "  \x1b[95mlet answer = 42              \x1b[0m \x1b[90m│\x1b[0m Create or assign a variable\n"
+    "  \x1b[95munset answer                 \x1b[0m \x1b[90m│\x1b[0m Remove a variable\n"
+    "  \x1b[95mvariables                    \x1b[0m \x1b[90m│\x1b[0m List current variables\n"
+    "  \x1b[95mdefine MAX 9                 \x1b[0m \x1b[90m│\x1b[0m Define a literal replacement\n"
+    "  \x1b[95m@MAX                         \x1b[0m \x1b[90m│\x1b[0m Use a definition\n"
+    "  \x1b[95mdefinitions                  \x1b[0m \x1b[90m│\x1b[0m List definitions\n"
+    "  \x1b[95mremove definition MAX        \x1b[0m \x1b[90m│\x1b[0m Remove a definition\n"
+    "    \x1b[95mdefine MAX 9\x1b[0m\n"
+    "    \x1b[95msearch elements number <= @MAX\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  FUNCTIONS & MACROS\x1b[0m\n"
+    "  \x1b[95mfunc square                  \x1b[0m \x1b[90m│\x1b[0m Start a function definition\n"
+    "  \x1b[95mreturn [\\1 * \\1]             \x1b[0m \x1b[90m│\x1b[0m Return a value using argument \\1\n"
+    "  \x1b[95mendfunc                      \x1b[0m \x1b[90m│\x1b[0m Finish a function definition\n"
+    "  \x1b[95msquare{5}                    \x1b[0m \x1b[90m│\x1b[0m Call a function\n"
+    "  \x1b[95mdefine double{}              \x1b[0m \x1b[90m│\x1b[0m Start a macro definition\n"
+    "  \x1b[95menddefine                    \x1b[0m \x1b[90m│\x1b[0m Finish a macro definition\n"
+    "  \x1b[95m@double{5}                   \x1b[0m \x1b[90m│\x1b[0m Expand and execute a macro\n"
+    "  \x1b[95mmacros                        \x1b[0m \x1b[90m│\x1b[0m List defined macros\n"
+    "  \x1b[2mFunction and macro arguments use positional placeholders: \\1, \\2, and so on.\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  CONTROL FLOW\x1b[0m\n"
+    "  \x1b[95mif condition ... endif         \x1b[0m \x1b[90m│\x1b[0m Conditional execution\n"
+    "  \x1b[95mif / elif / else / endif       \x1b[0m \x1b[90m│\x1b[0m Branch between conditions\n"
+    "  \x1b[95mfor item in iterable ... endfor\x1b[0m \x1b[90m│\x1b[0m Iterate over values\n"
+    "  \x1b[95mwhile condition ... endwhile   \x1b[0m \x1b[90m│\x1b[0m Repeat while a condition holds\n"
+    "  \x1b[95mbreak / continue               \x1b[0m \x1b[90m│\x1b[0m Control loop execution\n"
+    "    \x1b[95mfor i in range(5)\x1b[0m\n"
+    "        \x1b[95mlet value = i\x1b[0m\n"
+    "    \x1b[95mendfor\x1b[0m\n"
+    "  \x1b[2mPython-style blocks are also available: [for ...] ... [endblock].\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  ERROR HANDLING\x1b[0m\n"
+    "  \x1b[95mrisk ... endrisk             \x1b[0m \x1b[90m│\x1b[0m Run a protected block\n"
+    "  \x1b[95mfix                          \x1b[0m \x1b[90m│\x1b[0m Handle an error from the risk block\n"
+    "  \x1b[95mcleanup                      \x1b[0m \x1b[90m│\x1b[0m Run cleanup whether successful or not\n"
+    "  \x1b[95msignal \"message\"             \x1b[0m \x1b[90m│\x1b[0m Raise a ChemQL signal\n"
+    "  \x1b[95merror                        \x1b[0m \x1b[90m│\x1b[0m Inspect the error type in a fix block\n"
+    "    \x1b[95mrisk\x1b[0m\n"
+    "        \x1b[95msignal \"Something went wrong\"\x1b[0m\n"
+    "    \x1b[95mfix\x1b[0m\n"
+    "        \x1b[95mlet handled = error\x1b[0m\n"
+    "    \x1b[95mcleanup\x1b[0m\n"
+    "        \x1b[95mlet finished = true\x1b[0m\n"
+    "    \x1b[95mendrisk\x1b[0m\n"
+    "  \x1b[2mThe variable error contains the error type, or None after success.\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  STRUCTS & METHODS\x1b[0m\n"
+    "  \x1b[95mstruct Name                  \x1b[0m \x1b[90m│\x1b[0m Define a structured data type\n"
+    "  \x1b[95mrecord Name                  \x1b[0m \x1b[90m│\x1b[0m Define or use record data\n"
+    "  \x1b[95mfunc Type.__add__            \x1b[0m \x1b[90m│\x1b[0m Define an operator method\n"
+    "  \x1b[2mStruct methods can implement custom behaviour and operator overloads.\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  PYTHON INTEGRATION\x1b[0m\n"
+    "  \x1b[1;96m[x = 10]                     \x1b[0m \x1b[90m│\x1b[0m Execute a Python statement\n"
+    "  \x1b[1;96m[print(x)]                   \x1b[0m \x1b[90m│\x1b[0m Run Python code\n"
+    "  \x1b[1;96m[x * 2]                      \x1b[0m \x1b[90m│\x1b[0m Evaluate a Python expression\n"
+    "    \x1b[95m{{ search elements name = \"Hydrogen\" }}\x1b[0m\n"
+    "  \x1b[2mEmbedded {{ ... }} queries return results as values.\x1b[0m\n"
+    "  Multiline Python blocks:\n"
+    "    \x1b[95m[[[\x1b[0m\n"
+    "    \x1b[95mfor x in range(3):\x1b[0m\n"
+    "    \x1b[95m    print(x)\x1b[0m\n"
+    "    \x1b[95m]]]\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  SHELL, COMMENTS & COMPOSITION\x1b[0m\n"
+    "  \x1b[1;96m`command`                    \x1b[0m \x1b[90m│\x1b[0m Run a system-shell command\n"
+    "  \x1b[1;96m```bash ... ```              \x1b[0m \x1b[90m│\x1b[0m Run a multiline shell block\n"
+    "  \x1b[1;96m// comment                   \x1b[0m \x1b[90m│\x1b[0m Single-line comment\n"
+    "  \x1b[1;96m/// ... ///                  \x1b[0m \x1b[90m│\x1b[0m Multiline comment\n"
+    "  \x1b[1;96mcommand1; command2           \x1b[0m \x1b[90m│\x1b[0m Execute multiple commands\n"
+    "  \x1b[1;96m\\                            \x1b[0m \x1b[90m│\x1b[0m Continue input on the next line\n"
+    "  \x1b[1;96mview                         \x1b[0m \x1b[90m│\x1b[0m Open the periodic-table viewer\n"
+    "  \x1b[1;96mclear                        \x1b[0m \x1b[90m│\x1b[0m Clear the terminal\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  EXECUTION HISTORY\x1b[0m\n"
+    "  \x1b[92mdump FILE                     \x1b[0m \x1b[90m│\x1b[0m Export queries and results\n"
+    "  \x1b[92mdump all FILE                 \x1b[0m \x1b[90m│\x1b[0m Export all execution records\n"
+    "  \x1b[92mdump good FILE                \x1b[0m \x1b[90m│\x1b[0m Export successful executions\n"
+    "  \x1b[92mdump bad FILE                 \x1b[0m \x1b[90m│\x1b[0m Export failed executions\n"
+    "  \x1b[92mdump all|good|bad queries FILE\x1b[0m \x1b[90m│\x1b[0m Export query text only\n"
+    "  \x1b[92mdump all|good|bad results FILE\x1b[0m \x1b[90m│\x1b[0m Export results only\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  COMMAND-LINE OPTIONS\x1b[0m\n"
+    "  \x1b[1;96mchemql                       \x1b[0m \x1b[90m│\x1b[0m Start the interactive prompt\n"
+    "  \x1b[1;96mchemql -c \"COMMAND\"          \x1b[0m \x1b[90m│\x1b[0m Execute one command\n"
+    "  \x1b[1;96mchemql -f FILE               \x1b[0m \x1b[90m│\x1b[0m Execute a file\n"
+    "  \x1b[1;96mchemql --version             \x1b[0m \x1b[90m│\x1b[0m Display version information\n"
+    "  \x1b[1;96mchemql --no-ansi             \x1b[0m \x1b[90m│\x1b[0m Disable ANSI styling\n"
+    "  \x1b[1;96mchemql -c \"COMMAND\" -o FILE  \x1b[0m \x1b[90m│\x1b[0m Save command output to a file\n"
+    "  \x1b[1;96mchemql --upgrade [VERSION]   \x1b[0m \x1b[90m│\x1b[0m Upgrade ChemQL\n"
+    "  \x1b[1;96mchemql --force               \x1b[0m \x1b[90m│\x1b[0m Override package-manager protections\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m◆  PYTHON API\x1b[0m\n"
+    "    \x1b[95mfrom chemql import execute_query_text, execute_query\x1b[0m\n"
+    "    \x1b[95mresult = execute_query_text('search elements symbol = \"O\"')\x1b[0m\n"
+    "  \x1b[2mDistribution: chemql-python · Import and CLI name: chemql\x1b[0m\n"
+    "\n"
+    "\x1b[1;93m\x1b[1m⚠  SAFETY NOTES\x1b[0m\n"
+    "  \x1b[2mPython blocks and shell commands execute real code with your permissions.\x1b[0m\n"
+    "  \x1b[2mOnly run code and commands you trust. External lookups require network access.\x1b[0m\n"
+    "\n"
+    "\x1b[1;94m────────────────────────────────────────────────────────────────────────────────\x1b[0m\n"
+   f"\x1b[90mChemQL {__version__} · Type \x1b[92mhelp\x1b[90m for help, or \x1b[92mexit\x1b[90m to quit.\x1b[0m\n"
+)
 
-HELP = '\x1b[1;94m╭──────────────────────────────────────────────────────────────────────────────╮\x1b[0m\n\x1b[1;94m│\x1b[0m  \x1b[1;96m✦ \x1b[1mChemQL\x1b[0m \x1b[97mv1.2.0\x1b[0m \x1b[90m│\x1b[0m \x1b[1m\x1b[97mTHE PYTHON CHEMISTRY QUERY LANGUAGE\x1b[0m                         \x1b[1;94m│\x1b[0m\n\x1b[1;94m│\x1b[0m  \x1b[90mQuery chemical datasets · balance equations · embed Python · automate workflows\x1b[0m   \x1b[1;94m│\x1b[0m\n\x1b[1;94m╰──────────────────────────────────────────────────────────────────────────────╯\x1b[0m\n\n\x1b[1;93m\x1b[1m▶  QUICK START\x1b[0m\n  \x1b[92msearch elements ...          \x1b[0m \x1b[90m│\x1b[0m Query the periodic-table dataset\n  \x1b[92msearch molecules ...         \x1b[0m \x1b[90m│\x1b[0m Query molecule records\n  \x1b[92msearch reactions ...         \x1b[0m \x1b[90m│\x1b[0m Query stored reaction records\n  \x1b[92mfindel "He"                  \x1b[0m \x1b[90m│\x1b[0m Find an element by name or symbol\n  \x1b[92mfindmol "Water"              \x1b[0m \x1b[90m│\x1b[0m Find a molecule by name or formula\n  \x1b[92mfindre "Haber process"       \x1b[0m \x1b[90m│\x1b[0m Find a reaction by name, ID, or equation\n  \x1b[92mlist all                     \x1b[0m \x1b[90m│\x1b[0m List available fields and sources\n  \x1b[92mhelp  or  ?                  \x1b[0m \x1b[90m│\x1b[0m Show this help reference\n  \x1b[92mversion                      \x1b[0m \x1b[90m│\x1b[0m Show the installed version\n  \x1b[92mexit                         \x1b[0m \x1b[90m│\x1b[0m Leave the interactive prompt\n\n\x1b[1;93m\x1b[1m◆  QUERY SOURCES & EXAMPLES\x1b[0m\n  \x1b[92msearch elements [where]      \x1b[0m \x1b[90m│\x1b[0m Search element data\n  \x1b[92msearch molecules [where]     \x1b[0m \x1b[90m│\x1b[0m Search molecule data\n  \x1b[92msearch reactions [where]     \x1b[0m \x1b[90m│\x1b[0m Search reaction data\n  \x1b[1;96msource elements|molecules|reactions\x1b[0m \x1b[90m│\x1b[0m Set the current source\n    \x1b[95msearch elements symbol = "Fe" return name symbol number atomic_mass\x1b[0m\n    \x1b[95msearch molecules molecular_weight < 50 sort molecular_weight limit 10\x1b[0m\n    \x1b[95msearch reactions reversible = true return name equation source\x1b[0m\n\n\x1b[1;93m\x1b[1m◆  FILTERS & LOGIC\x1b[0m\n  \x1b[1;96m=   !=   >   <   >=   <=     \x1b[0m \x1b[90m│\x1b[0m Comparison operators\n  \x1b[1;96mlike  /  like!               \x1b[0m \x1b[90m│\x1b[0m Case-insensitive / case-sensitive wildcard matching\n  \x1b[1;96mlikep  /  has                \x1b[0m \x1b[90m│\x1b[0m Pattern matching / contains an item\n  \x1b[1;96mand  /  or  /  ( ... )       \x1b[0m \x1b[90m│\x1b[0m Combine conditions; parentheses group logic\n    \x1b[95msearch elements number > 10 and number < 20\x1b[0m\n    \x1b[95msearch molecules name like "*water*"\x1b[0m\n    \x1b[95msearch molecules (name like "*water*" or formula = "H2O") and molecular_weight < 25\x1b[0m\n\n\x1b[1;93m\x1b[1m◆  RESULT OPERATIONS\x1b[0m\n  \x1b[92mfirst  /  last               \x1b[0m \x1b[90m│\x1b[0m Return the first or last match\n  \x1b[92msort FIELD [asc|desc]        \x1b[0m \x1b[90m│\x1b[0m Sort matching records\n  \x1b[92mlimit N                      \x1b[0m \x1b[90m│\x1b[0m Limit the number of results\n  \x1b[92mcount                        \x1b[0m \x1b[90m│\x1b[0m Count matches\n  \x1b[92mreturn FIELD ...             \x1b[0m \x1b[90m│\x1b[0m Choose fields; one field lists, multiple fields form a table\n  \x1b[92munion / intersection         \x1b[0m \x1b[90m│\x1b[0m Combine result sets\n    \x1b[95msearch molecules molecular_weight < 20 sort molecular_weight asc limit 5\x1b[0m\n    \x1b[95msearch elements number < 10 union search elements number > 90\x1b[0m\n\n\x1b[1;93m\x1b[1m◆  REACTION TOOLS & CONDITIONS\x1b[0m\n  \x1b[1;96mset temperature 723K|150C|300F|standard|room    \x1b[0m \x1b[90m│\x1b[0m Set reaction temperature\n  \x1b[1;96mset pressure 101325Pa|2bar|1atm|standard|room   \x1b[0m \x1b[90m│\x1b[0m Set reaction pressure\n  \x1b[1;96mset catalysts iron zinc      \x1b[0m \x1b[90m│\x1b[0m Set the catalyst list\n  \x1b[1;96mset catalysts                \x1b[0m \x1b[90m│\x1b[0m Clear the catalyst list\n  \x1b[1;96madd catalyst "Vanadium oxide"\x1b[0m \x1b[90m│\x1b[0m Add a catalyst\n  \x1b[1;96mremove catalyst "Vanadium oxide"\x1b[0m \x1b[90m│\x1b[0m Remove a catalyst\n  \x1b[1;96mconditions                   \x1b[0m \x1b[90m│\x1b[0m Show active temperature, pressure, and catalysts\n  \x1b[1;96mreact N2 3H2                 \x1b[0m \x1b[90m│\x1b[0m Find a stored reaction matching reactants\n  \x1b[1;96mbalance H2 + O2 -> H2O       \x1b[0m \x1b[90m│\x1b[0m Balance an irreversible equation\n  \x1b[1;96mbalance N2 + H2 <-> NH3      \x1b[0m \x1b[90m│\x1b[0m Balance a reversible equation\n  \x1b[2mTemperature units: C, F, K. Pressure units include Pa, N/m^2, Nm^-2, bar, and atm.\x1b[0m\n  \x1b[2mPresets: standard = 0 C and 100000 Pa; room = 25 C and 101325 Pa.\x1b[0m\n\n\x1b[1;93m\x1b[1m◆  PREPROCESSOR, FUNCTIONS & MACROS  ·  V1.2.0\x1b[0m\n  \x1b[95mdefine MAX 9                 \x1b[0m \x1b[90m│\x1b[0m Define a literal replacement used as @MAX\n  \x1b[95mdefinitions                  \x1b[0m \x1b[90m│\x1b[0m List current literal definitions\n  \x1b[95mremove definition MAX        \x1b[0m \x1b[90m│\x1b[0m Remove a definition\n    \x1b[95mdefine MAX 9\x1b[0m\n    \x1b[95msearch elements number <= @MAX\x1b[0m\n\n  \x1b[95mfunc square                  \x1b[0m \x1b[90m│\x1b[0m Begin a function; finish it with endfunc\n  \x1b[95mreturn [\\1 * \\1]             \x1b[0m \x1b[90m│\x1b[0m Return a value using positional argument \\1\n  \x1b[95mendfunc                      \x1b[0m \x1b[90m│\x1b[0m Close the function definition\n  \x1b[95msquare{5}                    \x1b[0m \x1b[90m│\x1b[0m Call the function with brace-delimited arguments\n\n  \x1b[95mdefine light{}               \x1b[0m \x1b[90m│\x1b[0m Begin a macro; finish it with enddefine\n    \x1b[95msearch molecules molecular_weight < \\1 return name formula\x1b[0m\n  \x1b[95menddefine                    \x1b[0m \x1b[90m│\x1b[0m Close the macro definition\n  \x1b[95m@light{50}                   \x1b[0m \x1b[90m│\x1b[0m Expand and execute a macro\n  \x1b[2mFunction and macro arguments use positional placeholders: \\1, \\2, and so on.\x1b[0m\n  \x1b[2mDefinitions are processed in source order and are local to the current session.\x1b[0m\n\n\x1b[1;93m\x1b[1m◆  PYTHON INTEGRATION\x1b[0m\n  \x1b[1;96m[x = 10]                     \x1b[0m \x1b[90m│\x1b[0m Execute a Python statement\n  \x1b[1;96m[print(x)]                   \x1b[0m \x1b[90m│\x1b[0m Use Python variables across commands\n  \x1b[1;96m[x * 2]                      \x1b[0m \x1b[90m│\x1b[0m Evaluate and display a Python expression\n    \x1b[95m{{ search elements name = "Hydrogen" }}\x1b[0m\n  \x1b[2mEmbedded {{ ... }} queries return their result as a value.\x1b[0m\n  Python control-flow blocks:\n    \x1b[95m[if condition] ... [elif condition] ... [else] ... [endblock]\x1b[0m\n    \x1b[95m[for item in iterable] ... [endblock]\x1b[0m\n    \x1b[95m[while condition] ... [endblock]\x1b[0m\n    \x1b[95m[break] and [continue] inside loops\x1b[0m\n  Multiline Python block:\n    \x1b[95m[[[\x1b[0m\n    \x1b[95mfor x in range(3):\x1b[0m\n    \x1b[95m    print(x)\x1b[0m\n    \x1b[95m]]]   # close on its own line\x1b[0m\n\n\x1b[1;93m\x1b[1m◆  SHELL, COMMENTS & COMMAND COMPOSITION\x1b[0m\n  \x1b[1;96m`command`                    \x1b[0m \x1b[90m│\x1b[0m Run a command in the persistent system shell\n  \x1b[1;96m```bash ... ```              \x1b[0m \x1b[90m│\x1b[0m Run a multiline shell block (also sh, cmd, terminal)\n  \x1b[1;96m// comment                   \x1b[0m \x1b[90m│\x1b[0m Single-line comment\n  \x1b[1;96m/// ... ///                  \x1b[0m \x1b[90m│\x1b[0m Multiline comment\n  \x1b[1;96mcommand1; command2           \x1b[0m \x1b[90m│\x1b[0m Run multiple commands on one line\n  \x1b[1;96mtrailing backslash           \x1b[0m \x1b[90m│\x1b[0m Continue a command on the next line\n  \x1b[1;96mview                         \x1b[0m \x1b[90m│\x1b[0m Open the bundled periodic-table viewer\n  \x1b[1;96mclear                        \x1b[0m \x1b[90m│\x1b[0m Clear the terminal\n\n\x1b[1;93m\x1b[1m◆  HISTORY EXPORT\x1b[0m\n  \x1b[92mdump FILE                    \x1b[0m \x1b[90m│\x1b[0m Export all recorded queries and results\n  \x1b[92mdump all|good|bad FILE       \x1b[0m \x1b[90m│\x1b[0m Export all, successful, or failed executions\n  \x1b[92mdump all|good|bad queries FILE\x1b[0m \x1b[90m│\x1b[0m Export query history\n  \x1b[92mdump all|good|bad results FILE\x1b[0m \x1b[90m│\x1b[0m Export result history\n\n\x1b[1;93m\x1b[1m◆  COMMAND-LINE OPTIONS\x1b[0m\n  \x1b[1;96mchemql                       \x1b[0m \x1b[90m│\x1b[0m Start the interactive prompt\n  \x1b[1;96mchemql -c "COMMAND"          \x1b[0m \x1b[90m│\x1b[0m Execute one command\n  \x1b[1;96mchemql -f FILE               \x1b[0m \x1b[90m│\x1b[0m Execute commands from a file\n  \x1b[1;96mchemql --version             \x1b[0m \x1b[90m│\x1b[0m Print the installed version\n  \x1b[1;96mchemql --no-ansi             \x1b[0m \x1b[90m│\x1b[0m Disable ANSI styling in output\n  \x1b[1;96mchemql -c "COMMAND" -o FILE  \x1b[0m \x1b[90m│\x1b[0m Write command output to a plain-text file\n  \x1b[1;96mchemql --upgrade [VERSION]   \x1b[0m \x1b[90m│\x1b[0m Upgrade to latest or a chosen release\n  \x1b[1;96mchemql --force               \x1b[0m \x1b[90m│\x1b[0m Force upgrade past system-package protections\n\n\x1b[1;93m\x1b[1m◆  PYTHON API\x1b[0m\n    \x1b[95mfrom chemql import execute_query_text, execute_query\x1b[0m\n    \x1b[95mresult = execute_query_text(\'search elements symbol = "O"\')\x1b[0m\n  \x1b[2mDistribution package: chemql-python  ·  import / CLI name: chemql\x1b[0m\n\n\x1b[1;93m\x1b[1m⚠  SAFETY & DATA NOTES\x1b[0m\n  \x1b[2mPython blocks and shell commands run real code with your user permissions.\x1b[0m\n  \x1b[2mRun only code and commands you trust. External lookups need network access\x1b[0m\n  \x1b[2mand can fail when a remote service is unavailable.\x1b[0m\n\n\x1b[1;94m────────────────────────────────────────────────────────────────────────────────\x1b[0m\n\x1b[90mChemQL 1.2.0  ·  Type \x1b[92mhelp\x1b[90m for this guide, or \x1b[92mexit\x1b[90m to quit.\x1b[0m\n'
 
 import webbrowser
 from pathlib import Path
@@ -5142,7 +5312,7 @@ class ChemQLQuery:
         return ChemQLQuery(f"{self.query} intersection {other.query}")
 
     def __str__(self):
-        return f"Query of `{self.query}`"
+        return (f"Query of `{self.query}`" if NO_ANSI else f"Query of \033[1m{self.query}\033[22m")
 
     def __repr__(self):
         return str(self)
@@ -5311,7 +5481,7 @@ def _unclosed_expression_delimiters(lines):
     return expected
 
 
-def main():
+def main(ANSI: bool = True):
     parser = argparse.ArgumentParser(
         description="Chemql query and chemistry language"
     )
@@ -5374,7 +5544,7 @@ def main():
         sys.exit(upgrade_package(version_target, args.force))
 
     global NO_ANSI
-    NO_ANSI = args.no_ansi or bool(args.output)
+    NO_ANSI = not ANSI or args.no_ansi or bool(args.output)
 
     if args.output and args.command is None and args.file is None:
         parser.error("-o/--output requires -c/--command or -f/--file")
@@ -5517,7 +5687,7 @@ def run_interactive():
                 try:
                     print(_dump_history(first_line.strip()))
                 except Exception as exc:
-                    print(f"Error: {exc}")
+                    print(f"Error: {exc}" if NO_ANSI else "\033[31m" + f"Error: {exc}" + "\033[0m")
                 continue
         
             if not first_line.strip():
@@ -5652,7 +5822,7 @@ def run_interactive():
                         lines = []
                         break
                     except EOFError:
-                        message = "Missing `[endblock]`"
+                        message = ("Missing `[endblock]`" if NO_ANSI else "Missing \033[1m[endblock]\033[22m")
                         print("\n" + (message if NO_ANSI else "\033[31mMissing `\033[1m[endblock]\033[22m`\033[0m"))
                         lines = []
                         break
@@ -5675,4 +5845,4 @@ def run_interactive():
 
 
 if __name__ == "__main__":
-    main()
+    main(True)

{chemql_python-1.3.0 → chemql_python-1.3.2}/src/chemql/__main__.py

@@ -1,4 +1,4 @@
 from . import main
 
 
-main()
+main(True)

{chemql_python-1.3.0 → chemql_python-1.3.2/src/chemql_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.3.0
+Version: 1.3.2
 Summary: A chemistry-focused query language and REPL
 Author-email: Mohammad Rakibul Islam <rakibulofficial1017@gmail.com>
 Requires-Python: >=3.10
@@ -19,7 +19,7 @@ SQL-inspired syntax, inspect elements and molecules, look up reactions,
 balance equations, and combine chemistry queries with Python and shell
 commands.
 
--   **Version:** `1.3.0`
+-   **Version:** `1.3.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam