chemql-python 1.4.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

chemql/__init__.py

@@ -1,9 +1,12 @@
 import argparse
 import ast
 import atexit
+import builtins
 import contextlib
+from enum import Enum, auto
 from fractions import Fraction
 from functools import reduce
+import inspect
 import io
 import importlib
 import json
@@ -61,7 +64,7 @@ __all__ = [
     "__version__"
 ]
 
-__version__ = "1.4.2"
+__version__ = "1.5.0"
 
 # Persistent preprocessor/function state for the current ChemQL session.
 DEFINITIONS = {}
@@ -401,7 +404,7 @@ _BUILTIN_HELP = {
 }
 
 _HELP_TOPICS = {
-    "syntax": ("ChemQL Syntax", ["Function calls use braces: `name{arg1, arg2}`.", "Quote text containing spaces: `upper{\"hello world\"}`.", "Separate arguments with commas, not spaces.", "Python statements/expressions can be embedded in `[ ... ]`.", "Multiline Python uses `[[[ ... ]]]`; embedded queries use `{{ ... }}`."]),
+    "syntax": ("ChemQL Syntax", ["Function calls use braces: `name{arg1, arg2}`.", "Quote text containing spaces: `upper{\"hello world\"}`.", "Separate arguments with commas, not spaces.", "Python statements/expressions can be embedded in `[ ... ]`.", "Multiline Python uses `[[[ ... ]]]`; embedded queries use `{{ ... }}`.", "Enums use `enum Name`, member declarations, and `endenum`; omitted values are generated automatically.", "Structs and records may use `from Base`; structs inherit from structs, records, or Python classes, while records inherit only from records."]),
     "errors": ("ChemQL Error Signals", ["SyntaxError — the input could not be parsed as valid syntax.", "TooFewArguments — a function received fewer arguments than required.", "TooManyArguments — a function received more arguments than allowed.", "InvalidArgumentType — an argument has an unsupported type.", "InvalidArgumentValue — an argument's value is invalid.", "FileReadError — reading a file failed.", "FileWriteError — writing a file failed.", "NameError — a name or function is unknown.", "PermissionError — a private namespace function was called externally."]),
     "files": ("File Functions", ["read_text{path, encoding?}", "read_lines{path, encoding?}", "read_csv{path, delimiter?, encoding?, header?}", "read_json{path, encoding?}", "write_text{path, content, encoding?}", "write_csv{path, rows, delimiter?, encoding?}", "write_json{path, value, encoding?, indent?}", "file_exists{path}", "list_files{directory?, pattern?}"]),
     "chemistry": ("Chemistry Functions", ["molar_mass{formula}", "count_atoms{formula, element_symbol}", "empirical_formula{formula}", "element{symbol, field?}"]),
@@ -3442,6 +3445,7 @@ reaction_state = {
 python_globals = {"__builtins__": __builtins__, "math": math, "error": None}
 STRUCTS = {}
 RECORDS = {}
+ENUMS = {}
 
 class ChemQLSignal(Exception):
     """A user-raised, recoverable ChemQL error."""
@@ -4649,9 +4653,9 @@ def process_lines(lines):
                         block_end += 1
                     if block_end >= len(lines):
                         raise SyntaxError("Missing `endnamespace` after visibility declaration")
-                elif re.match(r"^(struct|record)\s+[A-Za-z_]\w*\s*$", declaration, re.IGNORECASE):
-                    kind = re.match(r"^(struct|record)", declaration, re.IGNORECASE).group(1).casefold() # type:ignore
-                    terminator = "endstruct" if kind == "struct" else "endrecord"
+                elif re.match(r"^(struct|record|enum)\s+[A-Za-z_]\w*(?:\s+from\s+(?:\[[^\]]+\]|[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*))?\s*$", declaration, re.IGNORECASE):
+                    kind = re.match(r"^(struct|record|enum)", declaration, re.IGNORECASE).group(1).casefold() # type:ignore
+                    terminator = {"struct": "endstruct", "record": "endrecord", "enum": "endenum"}[kind]
                     block_end = i + 1
                     while block_end < len(lines) and lines[block_end].strip().casefold() != terminator:
                         block_end += 1
@@ -4663,16 +4667,106 @@ def process_lines(lines):
             i = block_end + 1
             continue
 
-        type_match = re.fullmatch(r"(struct|record)\s+([A-Za-z_]\w*)", stripped, re.IGNORECASE)
+        enum_match = re.fullmatch(r"enum\s+([A-Za-z_]\w*)", stripped, re.IGNORECASE)
+        if enum_match:
+            type_name = enum_match.group(1)
+            end = i + 1
+            while end < len(lines) and lines[end].strip().casefold() != "endenum":
+                end += 1
+            if end >= len(lines):
+                raise SyntaxError(f"Missing `endenum` for enum `{type_name}`")
+            members = []
+            member_names = set()
+            for member_line in lines[i + 1:end]:
+                member_line = remove_comments(member_line).strip()
+                if not member_line:
+                    continue
+                member_match = re.fullmatch(r"([A-Za-z_]\w*)(?:\s*=\s*(.+))?", member_line)
+                if not member_match:
+                    raise SyntaxError(f"Invalid enum member declaration: {member_line}")
+                member_name, value_expression = member_match.groups()
+                if member_name in member_names:
+                    raise SyntaxError(f"Duplicate enum member `{member_name}` in {type_name}")
+                member_names.add(member_name)
+                value = auto() if value_expression is None else evaluate_python(_expand_definitions(value_expression))
+                members.append((member_name, value))
+            if not members:
+                raise SyntaxError(f"Enum `{type_name}` must declare members")
+            generated = Enum(type_name, members, module=__name__)
+            ENUMS[type_name] = generated
+            python_globals[type_name] = generated
+            i = end + 1
+            continue
+
+        type_match = re.fullmatch(
+            r"(struct|record)\s+([A-Za-z_]\w*)(?:\s+from\s+(\[[^\]]+\]|[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*))?",
+            stripped,
+            re.IGNORECASE,
+        )
         if type_match:
-            kind, type_name = type_match.group(1).casefold(), type_match.group(2)
+            kind, type_name, base_name = type_match.group(1).casefold(), type_match.group(2), type_match.group(3)
             terminator = "endstruct" if kind == "struct" else "endrecord"
             end = i + 1
             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}`" if NO_ANSI else f"Missing \033[1m{terminator}\033[22m for {kind} \033[1m{type_name}\033[22m"))
-            fields, defaults, required_fields, optional_fields = [], {}, [], []
+            parent = None
+            base_fields, base_required, defaults = [], [], {}
+            base_init_parameters = []
+            tuple_fields = ()
+            if base_name:
+                base_reference = base_name.strip()
+                if base_reference.startswith("[") and base_reference.endswith("]"):
+                    parent = evaluate_python(base_reference[1:-1].strip())
+                elif "." in base_reference:
+                    parent = evaluate_python(base_reference)
+                if kind == "record":
+                    if parent not in RECORDS.values():
+                        parent = RECORDS.get(base_reference)
+                    if parent is None:
+                        raise SyntaxError(f"Record `{type_name}` can only inherit from another record")
+                else:
+                    parent = (
+                        parent
+                        or STRUCTS.get(base_reference)
+                        or RECORDS.get(base_reference)
+                        or python_globals.get(base_reference)
+                        or getattr(builtins, base_reference, None)
+                    )
+                    if not isinstance(parent, type):
+                        raise SyntaxError(f"Unknown base class `{base_reference}` for struct `{type_name}`")
+                    if issubclass(parent, Enum):
+                        raise SyntaxError(f"Struct `{type_name}` cannot inherit from an enum")
+                if hasattr(parent, "_chemql_fields"):
+                    base_fields = list(parent._chemql_fields)
+                    base_required = list(parent._chemql_required)
+                    defaults.update(parent._chemql_defaults)
+                    tuple_fields = tuple(getattr(parent, "_chemql_tuple_fields", ()))
+                elif kind == "struct":
+                    try:
+                        parameters = list(inspect.signature(parent.__init__).parameters.values())[1:]
+                    except (TypeError, ValueError) as exc:
+                        raise SyntaxError(f"Cannot inspect constructor for base class `{base_name}`") from exc
+                    for parameter in parameters:
+                        if parameter.kind not in (
+                            inspect.Parameter.POSITIONAL_ONLY,
+                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                            inspect.Parameter.KEYWORD_ONLY,
+                        ):
+                            continue
+                        if not parameter.name.isidentifier():
+                            continue
+                        base_fields.append(parameter.name)
+                        if parameter.default is inspect.Parameter.empty:
+                            base_required.append(parameter.name)
+                        else:
+                            defaults[parameter.name] = parameter.default
+                        base_init_parameters.append(parameter)
+                if base_fields:
+                    tuple_fields = tuple(getattr(parent, "_chemql_tuple_fields", ()))
+
+            required_fields, optional_fields = [], []
             for field_line in lines[i + 1:end]:
                 field_line = remove_comments(field_line).strip()
                 if not field_line:
@@ -4690,7 +4784,7 @@ def process_lines(lines):
                         raise SyntaxError(f"Invalid {kind} field declaration: {field_line}")
                     field, default = match.groups()
                     is_required = False
-                if field in fields or field in required_fields or field in optional_fields:
+                if field in base_fields or field in required_fields or field in optional_fields:
                     raise SyntaxError((f"Duplicate field `{field}` in {type_name}" if NO_ANSI else f"Duplicate field \033[1m{field}\033[22m in {type_name}"))
                 if is_required:
                     required_fields.append(field)
@@ -4698,47 +4792,142 @@ def process_lines(lines):
                     optional_fields.append(field)
                     if default is not None:
                         defaults[field] = evaluate_python(_expand_definitions(default))
-            # Required struct fields always come first, preserving order within
-            # the required and optional groups. This makes positional calls
-            # consistent with the generated constructor signature.
-            fields = required_fields + optional_fields if kind == "struct" else optional_fields
-            if not fields:
+            declared_fields = required_fields + optional_fields if kind == "struct" else optional_fields
+            duplicate_fields = set(base_fields) & set(declared_fields)
+            if duplicate_fields:
+                raise SyntaxError(f"Field `{sorted(duplicate_fields)[0]}` is already inherited by {type_name}")
+            fields = base_fields + declared_fields
+            if not fields and parent is None:
                 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, required_names):
-                    def __init__(self, *args, **kwargs):
+                all_required = base_required + required_fields
+                own_fields = tuple(declared_fields)
+                native_constructor_base = parent in (
+                    int, float, complex, str, bytes, tuple, frozenset,
+                ) if parent is not None else False
+
+                def make_struct(
+                    class_name, base_class, field_names, required_names,
+                    field_defaults, declared_names, inherited_names,
+                    init_parameters, inherited_tuple_fields, base_is_record,
+                    native_constructor,
+                ):
+                    def bind_fields(*args, **kwargs):
                         if len(args) > len(field_names):
                             raise TypeError(f"{class_name} expected at most {len(field_names)} positional arguments")
                         values = dict(zip(field_names, args))
                         overlap = values.keys() & kwargs.keys()
                         if 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"))
+                            raise TypeError(f"Multiple values for field `{next(iter(overlap))}`")
                         values.update(kwargs)
                         extra = values.keys() - set(field_names)
                         if extra:
                             raise TypeError(f"Unexpected field(s): {', '.join(sorted(extra))}")
                         missing = [name for name in required_names if name not in values]
                         if missing:
-                            names = ", ".join(missing)
-                            raise TypeError(f"{class_name} missing required field(s): {names}")
-                        for field_name in field_names:
-                            setattr(self, field_name, values[field_name] if field_name in values else field_defaults.get(field_name))
-                    def __repr__(self):
-                        return class_name + "{ " + ", ".join(f"{f}={getattr(self, f)!r}" for f in field_names) + " }"
-                    def __eq__(self, other):
-                        return type(other) is type(self) and all(getattr(self, f) == getattr(other, f) for f in field_names)
-                    return type(class_name, (), {"__init__": __init__, "__repr__": __repr__, "__str__": __repr__, "__eq__": __eq__, "__slots__": tuple(field_names)})
-                generated = make_struct(type_name, fields, defaults, required_fields)
+                            raise TypeError(f"{class_name} missing required field(s): {', '.join(missing)}")
+                        return {field: values.get(field, field_defaults.get(field)) for field in field_names}
+
+                    def struct_init(self, *args, **kwargs):
+                        if native_constructor and not field_names:
+                            return
+                        values = bind_fields(*args, **kwargs)
+                        if base_class is not None:
+                            if hasattr(base_class, "_chemql_fields"):
+                                if not base_is_record:
+                                    base_class.__init__(self, **{field: values[field] for field in inherited_names})
+                            elif native_constructor:
+                                pass
+                            elif init_parameters:
+                                positional = [
+                                    values[param.name]
+                                    for param in init_parameters
+                                    if param.kind is inspect.Parameter.POSITIONAL_ONLY
+                                ]
+                                keywords = {
+                                    param.name: values[param.name]
+                                    for param in init_parameters
+                                    if param.kind in (
+                                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                                        inspect.Parameter.KEYWORD_ONLY,
+                                    )
+                                }
+                                base_class.__init__(self, *positional, **keywords)
+                            else:
+                                base_class.__init__(self)
+                        for field_name in declared_names:
+                            setattr(self, field_name, values[field_name])
+
+                    def struct_repr(self):
+                        return class_name + "{ " + ", ".join(
+                            f"{field}={getattr(self, field)!r}" for field in field_names
+                        ) + " }"
+
+                    def struct_eq(self, other):
+                        return type(other) is type(self) and all(
+                            getattr(self, field) == getattr(other, field) for field in field_names
+                        )
+
+                    attrs = {
+                        "__init__": struct_init,
+                        "_chemql_fields": tuple(field_names),
+                        "_chemql_required": tuple(required_names),
+                        "_chemql_defaults": dict(field_defaults),
+                        "_chemql_tuple_fields": inherited_tuple_fields,
+                    }
+                    if not (native_constructor and not field_names):
+                        attrs["__repr__"] = struct_repr
+                        attrs["__str__"] = struct_repr
+                        attrs["__eq__"] = struct_eq
+                    if inherited_tuple_fields:
+                        def struct_new(cls, *args, **kwargs):
+                            values = bind_fields(*args, **kwargs)
+                            return tuple.__new__(cls, tuple(values[field] for field in inherited_tuple_fields))
+                        attrs["__new__"] = struct_new
+                    elif native_constructor and not field_names:
+                        def struct_new(cls, *args, **kwargs):
+                            return base_class.__new__(cls, *args, **kwargs)
+                        attrs["__new__"] = struct_new
+                    else:
+                        attrs["__slots__"] = tuple(declared_names)
+                    return type(class_name, (base_class,) if base_class is not None else (), attrs)
+
+                generated = make_struct(
+                    type_name, parent, fields, all_required, defaults, own_fields,
+                    base_fields, base_init_parameters, tuple_fields,
+                    parent in RECORDS.values() if parent is not None else False,
+                    native_constructor_base,
+                )
                 STRUCTS[type_name] = generated
             else:
                 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:]):
+                if parent is None and any(f not in defaults for f in fields[first_default:]):
                     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"))
-                base_record = namedtuple(type_name + "Base", fields, defaults=[defaults[f] for f in fields[first_default:]])
-                def make_record(record_name, record_base, field_names):
+                if parent is None:
+                    base_record = namedtuple(type_name + "Base", fields, defaults=[defaults[f] for f in fields[first_default:]])
+                else:
+                    base_record = parent
+
+                def make_record(record_name, record_base, field_names, field_defaults, derived):
                     def _record_repr(self):
                         return record_name + " -> " + ", ".join(f"{field}: {getattr(self, field)}" for field in field_names)
+                    def _record_new(cls, *args, **kwargs):
+                        if len(args) > len(field_names):
+                            raise TypeError(f"{record_name} expected at most {len(field_names)} positional arguments")
+                        values = dict(zip(field_names, args))
+                        overlap = values.keys() & kwargs.keys()
+                        if overlap:
+                            raise TypeError(f"Multiple values for field `{next(iter(overlap))}`")
+                        values.update(kwargs)
+                        extra = values.keys() - set(field_names)
+                        if extra:
+                            raise TypeError(f"Unexpected field(s): {', '.join(sorted(extra))}")
+                        missing = [field for field in field_names if field not in values and field not in field_defaults]
+                        if missing:
+                            raise TypeError(f"{record_name} missing required field(s): {', '.join(missing)}")
+                        values = {field: values.get(field, field_defaults.get(field)) for field in field_names}
+                        return tuple.__new__(cls, tuple(values[field] for field in field_names))
                     def _binary_method(operation, reverse=False):
                         def method(self, other):
                             if type(other) is type(self):
@@ -4763,9 +4952,22 @@ def process_lines(lines):
                         "__pos__": lambda self: type(self)(*(+getattr(self, f) for f in field_names)),
                         "__abs__": lambda self: type(self)(*(abs(getattr(self, f)) for f in field_names)),
                     }
+                    if derived:
+                        attrs["__new__"] = _record_new
+                        attrs["_fields"] = tuple(field_names)
+                        attrs["__match_args__"] = tuple(field_names)
+                        attrs["_field_defaults"] = dict(field_defaults)
+                        attrs["__slots__"] = ()
+                        for index, field in enumerate(field_names):
+                            if field not in getattr(record_base, "_fields", ()):
+                                attrs[field] = property(lambda self, idx=index: self[idx])
                     return type(record_name, (record_base,), attrs)
-                generated = make_record(type_name, base_record, fields)
+                generated = make_record(type_name, base_record, fields, defaults, parent is not None)
                 RECORDS[type_name] = generated
+            generated._chemql_fields = tuple(fields)
+            generated._chemql_required = tuple(base_required + required_fields) if kind == "struct" else ()
+            generated._chemql_defaults = dict(defaults)
+            generated._chemql_tuple_fields = tuple_fields if kind == "struct" else tuple(fields)
             python_globals[type_name] = generated
             i = end + 1
             continue
@@ -5863,10 +6065,21 @@ HELP = (
     "  \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[95menum Name ... endenum        \x1b[0m \x1b[90m│\x1b[0m Define named values; omitted values auto-increment\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[95mstruct Name from Base        \x1b[0m \x1b[90m│\x1b[0m Inherit from structs, records, or Python classes\n"
+    "  \x1b[95mrecord Name [from Base]      \x1b[0m \x1b[90m│\x1b[0m Define a record; records inherit from records\n"
     "  \x1b[95mfunc Type.__add__            \x1b[0m \x1b[90m│\x1b[0m Define an operator method\n"
+    "  \x1b[2mEnum members use `Name.MEMBER`; explicit values can be mixed with automatic values.\x1b[0m\n"
     "  \x1b[2mStruct methods can implement custom behaviour and operator overloads.\x1b[0m\n"
+    "    \x1b[95menum Levels\x1b[0m\n"
+    "        \x1b[95mLOW = 50\x1b[0m\n"
+    "        \x1b[95mMEDIUM\x1b[0m\n"
+    "        \x1b[95mHIGH\x1b[0m\n"
+    "    \x1b[95mendenum\x1b[0m\n"
+    "    \x1b[95mstruct Dog from Animal\x1b[0m\n"
+    "        \x1b[95mcolor!\x1b[0m\n"
+    "    \x1b[95mendstruct\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"
@@ -5938,7 +6151,7 @@ class ChemqlLexer(Lexer):
         "findre", "set", "add", "remove", "react", "balance", "conditions",
         "view", "help", "dump", "version", "return", "union", "intersection",
         "let", "unset", "variables", "macros", "definitions", "arguments",
-        "define", "func", "struct", "record", "risk", "fix", "cleanup",
+        "define", "func", "struct", "record", "enum", "risk", "fix", "cleanup",
         "signal", "import", "remove", "load"
     }
     OPERATORS = {
@@ -5947,10 +6160,10 @@ class ChemqlLexer(Lexer):
     }
     CONTROL_WORDS = {
         "if", "elif", "else", "for", "while", "break", "continue", "endblock",
-        "endfor", "endwhile", "endif", "endrisk", "endstruct", "endrecord",
+        "endfor", "endwhile", "endif", "endrisk", "endstruct", "endrecord", "endenum",
         "endfunc", "enddefine", "func", "define", "struct", "record", "risk",
         "fix", "cleanup", "signal", "import", "as", "return", "public", "private",
-        "required", "namespace", "endnamespace"
+        "required", "namespace", "endnamespace", "enum", "from"
     }
     CONDITIONS = {
         "temperature", "pressure", "catalyst", "catalysts", "standard", "room",
@@ -5966,6 +6179,7 @@ class ChemqlLexer(Lexer):
             },
             "structs": set(STRUCTS),
             "records": set(RECORDS),
+            "enums": set(ENUMS),
             "functions": set(FUNCTIONS),
             "macros": set(MACROS),
             "definitions": set(DEFINITIONS),
@@ -5992,7 +6206,7 @@ class ChemqlLexer(Lexer):
 
             # Mark declaration names according to the declaration being edited.
             declaration = re.match(
-                r"(?:struct|record|func)\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?)", line[i:], re.I
+                r"(?:struct|record|enum|func)\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?)", line[i:], re.I
             )
             macro_declaration = re.match(r"define\s+([A-Za-z_]\w*)\s*\{\s*\}", line[i:], re.I)
             definition_declaration = re.match(r"define\s+([A-Za-z_]\w*)\s+", line[i:], re.I)
@@ -6002,7 +6216,7 @@ class ChemqlLexer(Lexer):
                 prefix = line[i:]
                 keyword = prefix.split(None, 1)[0].casefold()
                 declared_name = declaration.group(1)
-                declared_style = "struct" if keyword == "struct" else "record" if keyword == "record" else "function"
+                declared_style = "struct" if keyword == "struct" else "record" if keyword == "record" else "enum" if keyword == "enum" else "function"
             elif macro_declaration:
                 declared_name, declared_style = macro_declaration.group(1), "macro"
             elif definition_declaration:
@@ -6083,6 +6297,8 @@ class ChemqlLexer(Lexer):
                             style = "class:struct"
                         elif word in names["records"]:
                             style = "class:record"
+                        elif word in names["enums"]:
+                            style = "class:enum"
                         elif word in names["functions"] or word in function_names:
                             style = "class:function"
                         elif word in names["macros"]:
@@ -6126,11 +6342,11 @@ class ChemqlCompleter(Completer):
         "search", "source", "list", "clear", "return", "exit", "findel", "findmol",
         "findre", "set", "add", "remove", "react", "balance", "conditions", "version",
         "help", "view", "dump", "let", "unset", "variables", "func", "define", "struct",
-        "record", "risk", "fix", "cleanup", "signal", "import", "definitions", "macros",
-        "endfor", "endwhile", "endif", "endrisk", "endstruct", "endrecord", "endfunc", "enddefine",
+        "record", "enum", "risk", "fix", "cleanup", "signal", "import", "definitions", "macros",
+        "endfor", "endwhile", "endif", "endrisk", "endstruct", "endrecord", "endenum", "endfunc", "enddefine",
     )
     QUERY_OPERATORS = ["=", "!=", ">", "<", ">=", "<=", "like", "like!", "likep", "has", "sort", "limit", "count", "asc", "desc", "return", "and", "or", "union", "intersection"]
-    CONTROL_COMPLETIONS = ["if ", "for ", "while ", "endfor", "endwhile", "endif", "risk", "fix", "cleanup", "endrisk", "endstruct", "record ", "endrecord", "func ", "endfunc", "define ", "enddefine"]
+    CONTROL_COMPLETIONS = ["if ", "for ", "while ", "endfor", "endwhile", "endif", "risk", "fix", "cleanup", "endrisk", "struct ", "endstruct", "record ", "endrecord", "enum ", "endenum", "func ", "endfunc", "define ", "enddefine"]
 
     @staticmethod
     def _names():
@@ -6142,6 +6358,11 @@ class ChemqlCompleter(Completer):
             "variables": variables,
             "structs": set(STRUCTS),
             "records": set(RECORDS),
+            "enums": set(ENUMS),
+            "python_types": {
+                name for name, value in python_globals.items()
+                if isinstance(name, str) and isinstance(value, type) and not issubclass(value, Enum)
+            },
             "functions": set(FUNCTIONS),
             "macros": set(MACROS),
             "definitions": set(DEFINITIONS),
@@ -6210,12 +6431,17 @@ class ChemqlCompleter(Completer):
         elif command == "func":
             suggestions = sorted(names["structs"])
         elif command == "struct":
-            suggestions = sorted(names["structs"])
+            if len(command_words) >= 3 and command_words[2].casefold() == "from":
+                suggestions = sorted(names["structs"] | names["records"] | names["python_types"])
+            else:
+                suggestions = sorted(names["structs"])
         elif command == "record":
             suggestions = sorted(names["records"])
+        elif command == "enum":
+            suggestions = sorted(names["enums"])
         elif command in {"print", "return", "unset"}:
             suggestions = sorted(names["variables"])
-        elif command in {"risk", "fix", "cleanup", "endrisk", "endstruct", "endrecord", "endfunc", "enddefine", "endfor", "endwhile", "endif"}:
+        elif command in {"risk", "fix", "cleanup", "endrisk", "endstruct", "endrecord", "endenum", "endfunc", "enddefine", "endfor", "endwhile", "endif"}:
             suggestions = self.CONTROL_COMPLETIONS
 
         # In expressions, Python blocks, attribute access, and function calls,
@@ -6240,6 +6466,7 @@ chemql_style = Style.from_dict({
     "variable": "ansibrightgreen",
     "struct": "ansibrightblue bold",
     "record": "ansicyan bold",
+    "enum": "ansimagenta bold",
     "function": "ansiyellow bold",
     "macro": "ansimagenta bold",
     "definition": "ansibrightmagenta",
@@ -6468,7 +6695,10 @@ def _unclosed_expression_delimiters(lines):
 
 def main(ANSI: bool = True):
     parser = argparse.ArgumentParser(
-        description="Chemql query and chemistry language"
+        description=(
+            "ChemQL query and chemistry language.\n"
+            "Version 1.5.0 adds enums and inheritance for structs and records."
+        )
     )
 
     parser.add_argument(
@@ -6594,7 +6824,7 @@ def run_interactive():
             # such as `struct Fruit` and `record Point` are headers too.
             stack = []
             closers = {
-                "endrisk": "risk", "endstruct": "struct", "endrecord": "record",
+                "endrisk": "risk", "endstruct": "struct", "endrecord": "record", "endenum": "enum",
                 "endfunc": "func", "enddefine": "macro", "endfor": "for",
                 "endwhile": "while", "endif": "if", "[endblock]": "bracket", "endnamespace": "namespace"
             }
@@ -6606,10 +6836,13 @@ def run_interactive():
 
                 if re.fullmatch(r"namespace\s+[A-Za-z_]\w*", stripped, re.IGNORECASE):
                     stack.append("namespace")
-                if re.fullmatch(r"struct\s+[A-Za-z_]\w*", stripped, re.IGNORECASE):
+                declaration_line = re.sub(r"^(?:public|private)\s+", "", stripped, flags=re.IGNORECASE)
+                if re.fullmatch(r"struct\s+[A-Za-z_]\w*(?:\s+from\s+(?:\[[^\]]+\]|[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*))?", declaration_line, re.IGNORECASE):
                     stack.append("struct")
-                elif re.fullmatch(r"record\s+[A-Za-z_]\w*", stripped, re.IGNORECASE):
+                elif re.fullmatch(r"record\s+[A-Za-z_]\w*(?:\s+from\s+(?:\[[^\]]+\]|[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*))?", declaration_line, re.IGNORECASE):
                     stack.append("record")
+                elif re.fullmatch(r"enum\s+[A-Za-z_]\w*", declaration_line, re.IGNORECASE):
+                    stack.append("enum")
                 elif re.fullmatch(r"func\s+[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?", stripped, re.IGNORECASE):
                     stack.append("func")
                 elif re.fullmatch(r"define\s+[A-Za-z_]\w*\s*\{\s*\}", stripped, re.IGNORECASE):

{chemql_python-1.4.2.dist-info → chemql_python-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.4.2
+Version: 1.5.0
 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.4.1`
+-   **Version:** `1.5.0`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam
@@ -67,6 +67,9 @@ commands.
     matching.
 -   Use Python statements, expressions, variables, control flow,
     functions, macros, and structured values.
+-   Define enums with automatic or explicit values, and inherit structs
+      from structs, records, or Python classes; records can inherit from
+      other records.
 -   Execute shell commands and multiline shell blocks from the REPL.
 -   Export recorded commands and results.
 -   Use the command-line interface or import ChemQL from Python.
@@ -652,7 +655,8 @@ command lists definitions in the current session.
 
 ## Structs and records
 
-ChemQL 1.4.1 supports required fields, marked with a trailing `!` or the
+ChemQL 1.5.0 supports enums and inheritance in addition to required fields,
+marked with a trailing `!` or the
 `required` keyword:
 
 ```text
@@ -684,6 +688,87 @@ Special methods such as `__add__` are intended for custom behaviour, but
 do not assume every Python data-model feature or operator dispatch path
 is fully implemented.
 
+### Enums
+
+An enum member without an explicit value receives an automatically generated
+integer value. Automatic values continue from the preceding numeric value:
+
+```text
+enum Levels
+    LOW = 50
+    MEDIUM
+    HIGH
+endenum
+
+let selected = Levels.MEDIUM
+[selected.value] // 51
+```
+
+### Inheritance
+
+Structs can inherit fields and behavior from another struct, a record, or a
+Python class available in ChemQL's Python globals. Records can inherit only
+from other records:
+
+```text
+struct Animal
+    name!
+endstruct
+
+struct Dog from Animal
+    color!
+    isSmall = False
+endstruct
+
+let pet = Dog{"Rex", "brown"}
+pet.name
+pet.color
+
+record Identity
+    id
+endrecord
+
+record Product from Identity
+    name
+endrecord
+
+let item = Product{7, "Copper"}
+item.id
+item.name
+```
+
+Structs may also extend a Python class defined or imported into the active
+Python namespace. Built-in classes such as `int` can be named directly; a
+bracketed Python expression such as `[int]` is also accepted. Initializer
+parameters from ordinary Python classes become inherited constructor fields,
+and the Python initializer is called when the ChemQL struct is constructed.
+Native value types such as `int` keep their native constructor and value
+behavior:
+
+```text
+[[[
+class PythonAnimal:
+    def __init__(self, name):
+        self.name = name
+]]]
+
+struct Pet from PythonAnimal
+    species = "unknown"
+endstruct
+
+let pet = Pet{"Milo", "cat"}
+pet.name
+pet.species
+```
+
+```text
+struct Integer from int
+endstruct
+
+let answer = Integer{42}
+[answer + 1] // 43
+```
+
 ## Namespaces
 
 Namespaces group functions, structs, records, and variables. Members are

{chemql_python-1.4.2.dist-info → chemql_python-1.5.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-chemql/__init__.py,sha256=INIV28S5-HJkfc32Fpql9Cbn7tENAuHiPmmj69Zx6V0,272034
+chemql/__init__.py,sha256=Wz89yVuvYim_6yunWTW0TfDudEDBkmWSef7756hmjEs,285207
 chemql/__main__.py,sha256=5eIIUjMeE90JcHhOamg7KczBDQVHjMHNNCSshBQ6buw,32
 chemql/data/BondEnergies.json,sha256=QZN3iWZrD8125jV41EG1GiRohBtP0CzAP_EDQTfaEKc,8269
 chemql/data/MoleculeBonds.json,sha256=Iw2shYxJScH_tI80IytBYoqVDSbgT7OSqPJUIgKZme4,84262
@@ -19,9 +19,9 @@ chemql/stdlib/pathlib.cql,sha256=XkgWoPCtxW7tJKJokx52byb2RiWBKnVzG7X5uPfBFNQ,133
 chemql/stdlib/random.cql,sha256=Rvxbs-XP_gHUh0AmYmYl9WZXpJJJY3JpNNPn2HUobZU,742
 chemql/stdlib/text.cql,sha256=vBHE9b5SUxTQutaqViMteZeAC580Wg39J1eExkIx4yw,2038
 chemql/stdlib/math/statistics.cql,sha256=TVfazUbGGabUgAkLsg4LtPD8CaqZaj8mPnHbSuAmi40,1083
-chemql_python-1.4.2.dist-info/licenses/LICENSE,sha256=o4ywHC0EwRy2zgIASiRD2sK3Vcsf7LBcTHjDvoJgRE0,1079
-chemql_python-1.4.2.dist-info/METADATA,sha256=QeC1TFVbuH7-d6PHoSlXPvi52nLyza64rShUECCPjZc,27679
-chemql_python-1.4.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-chemql_python-1.4.2.dist-info/entry_points.txt,sha256=j98ObVWR743an524z24AiWeRsppag-py5cc7l0D0HkI,39
-chemql_python-1.4.2.dist-info/top_level.txt,sha256=9UzHwnk_F6W19Q9nayaFgVyAELQXXwoYjeBgB6MWNr8,7
-chemql_python-1.4.2.dist-info/RECORD,,
+chemql_python-1.5.0.dist-info/licenses/LICENSE,sha256=o4ywHC0EwRy2zgIASiRD2sK3Vcsf7LBcTHjDvoJgRE0,1079
+chemql_python-1.5.0.dist-info/METADATA,sha256=rsXs8GF7CfeUSe_usDVQ_rq8BlLjLf-OTJOMrc0o9f4,29414
+chemql_python-1.5.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chemql_python-1.5.0.dist-info/entry_points.txt,sha256=j98ObVWR743an524z24AiWeRsppag-py5cc7l0D0HkI,39
+chemql_python-1.5.0.dist-info/top_level.txt,sha256=9UzHwnk_F6W19Q9nayaFgVyAELQXXwoYjeBgB6MWNr8,7
+chemql_python-1.5.0.dist-info/RECORD,,