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

{chemql_python-1.3.1/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.1
+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.1`
+-   **Version:** `1.3.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam

{chemql_python-1.3.1 → 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.1`
+-   **Version:** `1.3.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam

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

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

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

@@ -52,7 +52,7 @@ __all__ = [
     "__version__"
 ]
 
-__version__ = "1.3.1"
+__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
 
@@ -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()
@@ -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
 
@@ -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,13 +4760,13 @@ 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 = (
@@ -5310,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)
@@ -5479,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"
     )
@@ -5542,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")
@@ -5820,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
@@ -5843,4 +5845,4 @@ def run_interactive():
 
 
 if __name__ == "__main__":
-    main()
+    main(True)

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

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

{chemql_python-1.3.1 → 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.1
+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.1`
+-   **Version:** `1.3.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam