chemql-python 1.6.0__tar.gz → 1.6.2__tar.gz

{chemql_python-1.6.0 → chemql_python-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.6.0
+Version: 1.6.2
 Summary: A chemistry-focused query language and REPL
 Author-email: Mohammad Rakibul Islam <rakibulofficial1017@gmail.com>
 Requires-Python: >=3.10
@@ -20,7 +20,7 @@ SQL-inspired syntax, inspect elements and molecules, look up reactions,
 balance equations, and combine chemistry queries with Python and shell
 commands.
 
--   **Version:** `1.6.0`
+-   **Version:** `1.6.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam
@@ -148,10 +148,11 @@ exit
 
 ### Terminal editor
 
-Install the package, then open a ChemQL file with the `codecql` command:
+Install the package, then open a ChemQL file with the `codecql` command or `chemql edit`:
 
 ``` bash
 codecql script.cql
+chemql edit script.cql # this works too
 ```
 
 The editor supports syntax highlighting, direct text editing, word movement
@@ -888,6 +889,73 @@ available before loading the package. `pathlib::read_text` and
 `pathlib::write_text` access files with the permissions of the ChemQL
 process.
 
+## Importing Package Members
+
+ChemQL allows you to import individual members from a package while retaining access to the package's other members through its qualified namespace.
+
+### Importing a Single Member
+
+Use `load MEMBER from PACKAGE` to import a specific member into the current scope.
+
+```chemql
+load sin from math
+
+sin{10}
+```
+
+The imported member can be called directly without specifying its package name.
+
+### Importing with an Alias
+
+You can use `as` to assign a different name to an imported member.
+
+```chemql
+load cos from math as c
+
+c{10}
+```
+
+This is useful when you want a shorter name or want to avoid naming conflicts.
+
+### Qualified Namespace Access
+
+Importing an individual member does not prevent you from accessing other members of its package. ChemQL can initialize the package as needed and resolve qualified function calls using the package namespace.
+
+```chemql
+load sin from math
+
+# Call the imported member directly
+sin{10}
+
+# Access other package members
+math::cos{10}
+math::sin{30}
+```
+
+You can therefore combine direct member imports with qualified calls in the same program.
+
+### Importing an Entire Package
+
+To load a package explicitly, use `load PACKAGE` or assign it an alias with `as`.
+
+```chemql
+load math
+
+math::sin{10}
+math::cos{10}
+```
+
+You can also assign a package alias:
+
+```chemql
+load math as MATH
+
+MATH::sin{10}
+MATH::cos{10}
+```
+
+**Note:** ChemQL's package initialization and namespace resolution allow qualified package functions to remain accessible even when you initially import only one member. Importing a member is therefore a convenience for direct access, not a restriction on the rest of the package.
+
 ## Built-in help
 
 The help system includes a general index and topic/function pages:

{chemql_python-1.6.0 → chemql_python-1.6.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.6.0`
+-   **Version:** `1.6.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam
@@ -134,10 +134,11 @@ exit
 
 ### Terminal editor
 
-Install the package, then open a ChemQL file with the `codecql` command:
+Install the package, then open a ChemQL file with the `codecql` command or `chemql edit`:
 
 ``` bash
 codecql script.cql
+chemql edit script.cql # this works too
 ```
 
 The editor supports syntax highlighting, direct text editing, word movement
@@ -874,6 +875,73 @@ available before loading the package. `pathlib::read_text` and
 `pathlib::write_text` access files with the permissions of the ChemQL
 process.
 
+## Importing Package Members
+
+ChemQL allows you to import individual members from a package while retaining access to the package's other members through its qualified namespace.
+
+### Importing a Single Member
+
+Use `load MEMBER from PACKAGE` to import a specific member into the current scope.
+
+```chemql
+load sin from math
+
+sin{10}
+```
+
+The imported member can be called directly without specifying its package name.
+
+### Importing with an Alias
+
+You can use `as` to assign a different name to an imported member.
+
+```chemql
+load cos from math as c
+
+c{10}
+```
+
+This is useful when you want a shorter name or want to avoid naming conflicts.
+
+### Qualified Namespace Access
+
+Importing an individual member does not prevent you from accessing other members of its package. ChemQL can initialize the package as needed and resolve qualified function calls using the package namespace.
+
+```chemql
+load sin from math
+
+# Call the imported member directly
+sin{10}
+
+# Access other package members
+math::cos{10}
+math::sin{30}
+```
+
+You can therefore combine direct member imports with qualified calls in the same program.
+
+### Importing an Entire Package
+
+To load a package explicitly, use `load PACKAGE` or assign it an alias with `as`.
+
+```chemql
+load math
+
+math::sin{10}
+math::cos{10}
+```
+
+You can also assign a package alias:
+
+```chemql
+load math as MATH
+
+MATH::sin{10}
+MATH::cos{10}
+```
+
+**Note:** ChemQL's package initialization and namespace resolution allow qualified package functions to remain accessible even when you initially import only one member. Importing a member is therefore a convenience for direct access, not a restriction on the rest of the package.
+
 ## Built-in help
 
 The help system includes a general index and topic/function pages:

{chemql_python-1.6.0 → chemql_python-1.6.2}/pyproject.toml

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

{chemql_python-1.6.0 → chemql_python-1.6.2}/src/chemql/__init__.py

@@ -68,7 +68,7 @@ __all__ = [
     "__version__"
 ]
 
-__version__ = "1.6.0"
+__version__ = "1.6.2"
 
 # Persistent preprocessor/function state for the current ChemQL session.
 DEFINITIONS = {}
@@ -1094,6 +1094,24 @@ def _expand_function_calls(text):
             if match:
                 name = match.group(1)
                 resolved_name = _resolve_package_qualified_name(name)
+                # Enforce explicit package loading BEFORE checking FUNCTIONS.
+                # Otherwise a function registered while internally initializing
+                # a package bypasses the qualified-access restriction below.
+                if "::" in resolved_name:
+                    package_name = resolved_name.rsplit("::", 1)[0]
+                    root_package = package_name.split("::", 1)[0]
+                    explicitly_loaded_packages = globals().get(
+                        "CHEMQL_EXPLICITLY_LOADED_PACKAGES", set()
+                    )
+                    if (
+                        package_name not in explicitly_loaded_packages
+                        and root_package not in explicitly_loaded_packages
+                    ):
+                        raise ChemQLError(
+                            f"Unknown function `{name}`"
+                            if NO_ANSI else
+                            f"Unknown function \\033[1m{name}\\033[22m"
+                        )
                 opening = i + match.end() - 1
                 end = find_matching(text, opening, "{", "}")
                 args = _split_function_arguments(text[opening + 1:end])
@@ -1103,6 +1121,47 @@ def _expand_function_calls(text):
                     value = _call_function(resolved_name, args)
                 elif "::" not in resolved_name and resolved_name in BUILTIN_FUNCTIONS:
                     value = _call_builtin(resolved_name, args)
+                elif (
+                    "::" not in resolved_name
+                    and resolved_name in CHEMQL_VARIABLES
+                    and callable(python_globals.get(resolved_name))
+                ):
+                    # `load member from package` binds the actual public member
+                    # in the global scope. Imported function wrappers therefore
+                    # need to be callable through the same `name{args}` syntax
+                    # as registered ChemQL functions.
+                    imported_callable = python_globals[resolved_name]
+                    values = [evaluate_python(arg) for arg in args]
+                    value = imported_callable(*values)
+                elif "::" in resolved_name:
+                    # A qualified call is permitted only after the user has
+                    # explicitly loaded its package (possibly under an alias).
+                    # `_ensure_package_namespace()` is also used internally by
+                    # `load MEMBER from package`; that internal initialization
+                    # must not make every member of the package accessible.
+                    package_name = resolved_name.rsplit("::", 1)[0]
+                    root_package = package_name.split("::", 1)[0]
+                    explicitly_loaded_packages = globals().get(
+                        "CHEMQL_EXPLICITLY_LOADED_PACKAGES", set()
+                    )
+                    # Explicit imports are tracked separately from package bindings:
+                    # internal package initialization and incidental bindings must not
+                    # expose sibling members through qualified calls.
+                    explicitly_loaded = (
+                        package_name in explicitly_loaded_packages
+                        or root_package in explicitly_loaded_packages
+                    )
+                    if explicitly_loaded:
+                        try:
+                            _ensure_package_namespace(package_name)
+                        except (ImportError, OSError, ValueError):
+                            pass
+                    if explicitly_loaded and resolved_name in FUNCTIONS:
+                        if not _namespace_function_is_callable(resolved_name):
+                            raise PermissionError((f"Function `{name}` is private" if NO_ANSI else f"Function \033[1m{name}\033[22m is private"))
+                        value = _call_function(resolved_name, args)
+                    else:
+                        raise ChemQLError((f"Unknown function `{name}`" if NO_ANSI else f"Unknown function \033[1m{name}\033[22m"))
                 elif (
                     "::" not in resolved_name
                     and isinstance(python_globals.get(resolved_name), type)
@@ -4571,6 +4630,9 @@ def _find_unquoted_marker(text, marker, start=0):
 # Canonical ChemQL package names and user-defined aliases are deliberately
 # tracked separately. An alias must never replace a canonical package binding.
 CHEMQL_PACKAGE_BINDINGS = {}
+# Tracks packages explicitly imported by the user. Internal namespace initialization
+# for `load MEMBER from package` must not grant qualified-call access.
+CHEMQL_EXPLICITLY_LOADED_PACKAGES = set()
 CHEMQL_PACKAGE_SOURCE_LOADED = set()
 
 
@@ -4706,22 +4768,42 @@ def _ensure_package_namespace(package_name, allow_namespace_only=False):
             globals()["_CURRENT_VISIBILITY"] = old_visibility
         CHEMQL_PACKAGE_SOURCE_LOADED.add(package_name)
 
-    # A namespace-only parent is a canonical container, not an independently
-    # loadable package unless it has its own .cql source file.
-    if path is not None:
-        CHEMQL_PACKAGE_BINDINGS.setdefault(package_name, package_name)
+    # Merely resolving a package namespace must not count as a user-visible
+    # package import. `_execute_load_statement` records bindings explicitly.
     return namespace
 
 
 def _execute_load_statement(statement):
-    """Load a ChemQL .cql package, optionally binding an explicit alias."""
+    """Load a package, optionally alias it or import one public member."""
+    from_match = re.fullmatch(
+        r"load\s+([A-Za-z_]\w*)\s+from\s+([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)(?:\s+as\s+([A-Za-z_]\w*))?",
+        statement,
+    )
+    if from_match:
+        member_name, package_name, alias = from_match.groups()
+        binding_name = alias or member_name
+        namespace = _ensure_package_namespace(package_name)
+        if member_name not in namespace._chemql_public:
+            raise ImportError(f"Package `{package_name}` has no public member `{member_name}`")
+        value = getattr(namespace, member_name)
+        # Bind only the requested member, under either its original name or
+        # the explicit alias. Loading the source is necessary to resolve it,
+        # but does not create a package-name binding in the user's globals.
+        if binding_name in CHEMQL_PACKAGE_BINDINGS:
+            raise ImportError(f"Name `{binding_name}` is already bound as a package name; cannot import `{member_name}` from `{package_name}`.")
+        if binding_name in CHEMQL_VARIABLES:
+            raise ImportError(f"Name `{binding_name}` is already defined; cannot import `{member_name}` from `{package_name}`.")
+        python_globals[binding_name] = value
+        CHEMQL_VARIABLES.add(binding_name)
+        return True
+
     match = re.fullmatch(
         r"load\s+([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)(?:\s+as\s+([A-Za-z_]\w*))?",
         statement,
     )
     if not match:
         if statement.startswith("load"):
-            raise SyntaxError(("Expected `load package::name` or `load package::name as alias`" if NO_ANSI else "Expected \033[1mload package::name\033[22m or \033[1mload package::name as alias\033[22m"))
+            raise SyntaxError(("Expected `load package`, `load package as alias`, or `load MEMBER from package [as alias]`" if NO_ANSI else "Expected \033[1mload package\033[22m, \033[1mload package as alias\033[22m, or \033[1mload MEMBER from package [as alias]\033[22m"))
         return False
 
     package_name, alias = match.groups()
@@ -4827,6 +4909,10 @@ def _execute_load_statement(statement):
             CHEMQL_PACKAGE_BINDINGS[package_name] = package_name
             python_globals[package_name] = namespace
             CHEMQL_VARIABLES.add(package_name)
+
+    # Only `load package [as alias]` reaches this point. Member imports return
+    # earlier, so they never grant qualified access to sibling package members.
+    CHEMQL_EXPLICITLY_LOADED_PACKAGES.add(package_name)
     return True
 
 
@@ -6538,7 +6624,7 @@ class ChemqlLexer(Lexer):
     CONTROL_WORDS = {
         "if", "elif", "else", "for", "while", "break", "continue", "endblock",
         "endfor", "endwhile", "endif", "endrisk", "endstruct", "endrecord", "endenum",
-        "endfunc", "enddefine", "func", "define", "struct", "record", "risk",
+        "endfunc", "enddefine", "func", "define", "struct", "record", "risk", "static",
         "fix", "cleanup", "signal", "import", "as", "return", "public", "private",
         "required", "namespace", "endnamespace", "enum", "from"
     }
@@ -7437,6 +7523,12 @@ def _init_project(name=None, directory="."):
 
 
 def main(ANSI: bool = True):
+    if len(sys.argv) >= 2 and sys.argv[1] == "edit":
+        from .codecql import main as codecql_main # type: ignore
+
+        sys.argv = ["codecql"] + sys.argv[2:]
+        codecql_main()
+        return
     parser = argparse.ArgumentParser(
         description=(
             "ChemQL query and chemistry language.\n"
@@ -7586,7 +7678,7 @@ def run_interactive():
                 closer = "]]]" if first == "[[[" else "```"
                 return not (len(source_lines) > 1 and last == closer)
 
-            if re.fullmatch(r"(?:(?:static\s+func|func\s+static|func)\s+)" + _DEFINITION_NAME, first, re.IGNORECASE):
+            if re.fullmatch(r"(?:(?:static\s+func|func\s+static|func)\s+)" + _DEFINITION_NAME + "(?:\\." + _DEFINITION_NAME + ")?" , first, re.IGNORECASE):
                 return last.casefold() != "endfunc"
 
             if re.fullmatch(r"define\s+" + _DEFINITION_NAME + r"\s*\{\s*\}", first):

{chemql_python-1.6.0 → chemql_python-1.6.2}/src/chemql/codecql.py

@@ -10,7 +10,7 @@ import shutil
 import subprocess
 import time
 
-VERSION = "0.0.8"
+VERSION = "0.0.10"
 
 
 def _write_system_clipboard(text):
@@ -275,7 +275,7 @@ COMMANDS = {
 CONTROL_KEYWORDS = {
     "if", "elif", "else", "endif", "for", "while", "in", "endfor",
     "endwhile", "break", "continue", "endblock", "from", "as", "public",
-    "private", "required", "struct", "record", "enum", "endstruct",
+    "private", "required", "struct", "record", "enum", "endstruct", "static",
     "endrecord", "endenum", "namespace", "endnamespace",
 }
 WORD_OPERATORS = {
@@ -357,7 +357,76 @@ def _token_style(kind, value):
     return HIGHLIGHT_STYLES[category]
 
 
-def apply_syntax_highlighting(text):
+MANIFEST_TOKEN_RE = re.compile(
+    r"(?P<comment>#.*$)"
+    r"|(?P<string>'(?:\\.|[^'\\])*'|\"(?:\\.|[^\"\\])*\")"
+    r"|(?P<number>(?<![\w.])[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?!\w))"
+    r"|(?P<literal>\b(?:true|false|null)\b)"
+    r"|(?P<identifier>[A-Za-z_][A-Za-z0-9_-]*)"
+    r"|(?P<operator>=)"
+    r"|(?P<delimiter>[\[\]{}:,.])",
+    re.IGNORECASE,
+)
+
+def _apply_manifest_syntax_highlighting(text, filename):
+    """Highlight JSON/TOML package manifests with the editor's existing theme."""
+    is_json = os.path.basename(filename).casefold() == "cqlpackage.json"
+    is_toml = os.path.basename(filename).casefold() == "cqlpackage.toml"
+    if not (is_json or is_toml):
+        return None
+
+    # TOML table headers are clearer when highlighted as a unit.
+    stripped = text.lstrip()
+    if is_toml and stripped.startswith("[") and stripped.endswith("]"):
+        leading = text[:len(text) - len(stripped)]
+        return leading + HIGHLIGHT_STYLES["type"] + stripped + RESET
+
+    parts = []
+    last_end = 0
+    for match in MANIFEST_TOKEN_RE.finditer(text):
+        parts.append(text[last_end:match.start()])
+        token = match.group()
+        kind = match.lastgroup
+        tail = text[match.end():]
+        style = ""
+
+        if kind == "comment" and is_toml:
+            style = HIGHLIGHT_STYLES["comment"]
+        elif kind == "string":
+            next_nonspace = tail.lstrip()[:1]
+            if (is_json and next_nonspace == ":") or (is_toml and next_nonspace == "="):
+                style = HIGHLIGHT_STYLES["property"]
+            else:
+                style = HIGHLIGHT_STYLES["string"]
+        elif kind == "number":
+            style = HIGHLIGHT_STYLES["number"]
+        elif kind == "literal":
+            # JSON literals are lowercase; TOML booleans are lowercase too.
+            style = HIGHLIGHT_STYLES["constant"]
+        elif kind == "identifier" and is_toml:
+            if tail.lstrip().startswith("="):
+                style = HIGHLIGHT_STYLES["property"]
+            elif token.casefold() in {"true", "false", "inf", "nan"}:
+                style = HIGHLIGHT_STYLES["constant"]
+        elif kind == "operator":
+            style = HIGHLIGHT_STYLES["operator"]
+        elif kind == "delimiter" and token.strip():
+            style = HIGHLIGHT_STYLES["delimiter"]
+
+        if style:
+            parts.extend((style, token, RESET))
+        else:
+            parts.append(token)
+        last_end = match.end()
+    parts.append(text[last_end:])
+    return "".join(parts)
+
+
+def apply_syntax_highlighting(text, filename=None):
+    if filename:
+        manifest_highlighting = _apply_manifest_syntax_highlighting(text, filename)
+        if manifest_highlighting is not None:
+            return manifest_highlighting
     parts = []
     last_end = 0
     for match in TOKEN_RE.finditer(text):
@@ -495,7 +564,7 @@ class Editor:
                 current = (match_start, match_end) == self.current_search_match
                 overlays.append((start, end, "\x1b[7m" if current else "\x1b[43m", 1))
         if not overlays:
-            return apply_syntax_highlighting(visible_text)
+            return apply_syntax_highlighting(visible_text, self.filename)
 
         boundaries = {line_start, line_end}
         for start, end, _, _ in overlays:
@@ -520,7 +589,7 @@ class Editor:
                 style = max(active, key=lambda overlay: overlay[3])[2]
                 parts.extend((style, segment, RESET))
             else:
-                parts.append(apply_syntax_highlighting(segment))
+                parts.append(apply_syntax_highlighting(segment, self.filename))
         return "".join(parts)
 
     def _keep_cursor_visible(self, height, width, visual_cursor_x):
@@ -628,8 +697,9 @@ class Editor:
             self._insert_newline()
         elif key == "\t":
             self._insert_text("\t")
-        elif key and key.isprintable() and "+" not in key:
-            # Symbolic key names (e.g. "alt+delete") are control events, not text.
+        elif key and key.isprintable() and (len(key) == 1 or "+" not in key):
+            # Single printable characters (including '+') are text; multi-part
+            # names such as "alt+delete" are symbolic key events.
             self._insert_text(key)
         if key not in ("\x11",):
             self.quit_requested = False

{chemql_python-1.6.0 → chemql_python-1.6.2}/src/chemql_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemql-python
-Version: 1.6.0
+Version: 1.6.2
 Summary: A chemistry-focused query language and REPL
 Author-email: Mohammad Rakibul Islam <rakibulofficial1017@gmail.com>
 Requires-Python: >=3.10
@@ -20,7 +20,7 @@ SQL-inspired syntax, inspect elements and molecules, look up reactions,
 balance equations, and combine chemistry queries with Python and shell
 commands.
 
--   **Version:** `1.6.0`
+-   **Version:** `1.6.2`
 -   **PyPI distribution:** `chemql-python`
 -   **Python import / CLI name:** `chemql`
 -   **Author:** Mohammad Rakibul Islam
@@ -148,10 +148,11 @@ exit
 
 ### Terminal editor
 
-Install the package, then open a ChemQL file with the `codecql` command:
+Install the package, then open a ChemQL file with the `codecql` command or `chemql edit`:
 
 ``` bash
 codecql script.cql
+chemql edit script.cql # this works too
 ```
 
 The editor supports syntax highlighting, direct text editing, word movement
@@ -888,6 +889,73 @@ available before loading the package. `pathlib::read_text` and
 `pathlib::write_text` access files with the permissions of the ChemQL
 process.
 
+## Importing Package Members
+
+ChemQL allows you to import individual members from a package while retaining access to the package's other members through its qualified namespace.
+
+### Importing a Single Member
+
+Use `load MEMBER from PACKAGE` to import a specific member into the current scope.
+
+```chemql
+load sin from math
+
+sin{10}
+```
+
+The imported member can be called directly without specifying its package name.
+
+### Importing with an Alias
+
+You can use `as` to assign a different name to an imported member.
+
+```chemql
+load cos from math as c
+
+c{10}
+```
+
+This is useful when you want a shorter name or want to avoid naming conflicts.
+
+### Qualified Namespace Access
+
+Importing an individual member does not prevent you from accessing other members of its package. ChemQL can initialize the package as needed and resolve qualified function calls using the package namespace.
+
+```chemql
+load sin from math
+
+# Call the imported member directly
+sin{10}
+
+# Access other package members
+math::cos{10}
+math::sin{30}
+```
+
+You can therefore combine direct member imports with qualified calls in the same program.
+
+### Importing an Entire Package
+
+To load a package explicitly, use `load PACKAGE` or assign it an alias with `as`.
+
+```chemql
+load math
+
+math::sin{10}
+math::cos{10}
+```
+
+You can also assign a package alias:
+
+```chemql
+load math as MATH
+
+MATH::sin{10}
+MATH::cos{10}
+```
+
+**Note:** ChemQL's package initialization and namespace resolution allow qualified package functions to remain accessible even when you initially import only one member. Importing a member is therefore a convenience for direct access, not a restriction on the rest of the package.
+
 ## Built-in help
 
 The help system includes a general index and topic/function pages: