quantum-framework 0.9.1__tar.gz → 0.11.0__tar.gz

{quantum_framework-0.9.1/quantum_framework.egg-info → quantum_framework-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.9.1
+Version: 0.11.0
 Summary: Full-stack declarative framework for building web, desktop, and mobile applications
 Author-email: Daniel Gregorio <danielgregorio2611@gmail.com>
 License: MIT
@@ -216,7 +216,7 @@ Full docs at **[danielgregorio.github.io/quantum](https://danielgregorio.github.
 
 - [Getting Started](https://danielgregorio.github.io/quantum/guide/getting-started) · [Installation](https://danielgregorio.github.io/quantum/guide/installation) · [Quick Start](https://danielgregorio.github.io/quantum/guide/quick-start)
 - [Components](https://danielgregorio.github.io/quantum/guide/components) · [State](https://danielgregorio.github.io/quantum/guide/state-management) · [Loops](https://danielgregorio.github.io/quantum/guide/loops) · [Conditionals](https://danielgregorio.github.io/quantum/guide/conditionals)
-- [Queries](https://danielgregorio.github.io/quantum/guide/query) · [Functions](https://danielgregorio.github.io/quantum/guide/functions) · [Data fetching](https://danielgregorio.github.io/quantum/guide/data-fetching)
+- [Queries](https://danielgregorio.github.io/quantum/guide/query) · [Functions](https://danielgregorio.github.io/quantum/guide/functions)
 
 Releases and their notes are on the [GitHub Releases](https://github.com/danielgregorio/quantum/releases) page.
 

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/README.md

@@ -173,7 +173,7 @@ Full docs at **[danielgregorio.github.io/quantum](https://danielgregorio.github.
 
 - [Getting Started](https://danielgregorio.github.io/quantum/guide/getting-started) · [Installation](https://danielgregorio.github.io/quantum/guide/installation) · [Quick Start](https://danielgregorio.github.io/quantum/guide/quick-start)
 - [Components](https://danielgregorio.github.io/quantum/guide/components) · [State](https://danielgregorio.github.io/quantum/guide/state-management) · [Loops](https://danielgregorio.github.io/quantum/guide/loops) · [Conditionals](https://danielgregorio.github.io/quantum/guide/conditionals)
-- [Queries](https://danielgregorio.github.io/quantum/guide/query) · [Functions](https://danielgregorio.github.io/quantum/guide/functions) · [Data fetching](https://danielgregorio.github.io/quantum/guide/data-fetching)
+- [Queries](https://danielgregorio.github.io/quantum/guide/query) · [Functions](https://danielgregorio.github.io/quantum/guide/functions)
 
 Releases and their notes are on the [GitHub Releases](https://github.com/danielgregorio/quantum/releases) page.
 

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.9.1"
+version = "0.11.0"
 description = "Full-stack declarative framework for building web, desktop, and mobile applications"
 readme = "README.md"
 license = {text = "MIT"}

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/quantum/cli/commands/migrate.py

@@ -1,6 +1,6 @@
 """
 Quantum CLI - Database Migration Commands
-Handles database migrations with automatic PostgreSQL/SQLite failover
+Applies migrations to a datasource declared in quantum.config.yaml (DB-6)
 """
 import os
 import sys
@@ -44,95 +44,76 @@ class Migration:
 
 
 class DatabaseConnection:
-    """Database connection with automatic failover"""
+    """Connection to the datasource the migrations are for (DB-6).
 
-    def __init__(self, project_path: Path = None):
+    It used to read a separate `database:` section that nothing else uses and,
+    without one, try a PostgreSQL at localhost/quantum with user postgres before
+    falling back to ./data/quantum.db. A project whose pages query
+    datasources.db (./data/app.db) had its migrations applied to a different
+    file — or to whatever local PostgreSQL answered.
+    """
+
+    def __init__(self, project_path: Path = None, datasource: str = None):
         self.project_path = project_path or Path.cwd()
+        self.datasource = datasource
         self._conn = None
         self._db_type = None
 
     def connect(self) -> Any:
-        """
-        Connect to database with automatic failover.
-        Tries PostgreSQL first, falls back to SQLite.
-        """
-        # Try to load database config from quantum.config.yaml
-        config = self._load_config()
-
-        # Try PostgreSQL
-        if self._try_postgres(config):
+        nome, config = self._datasource_config()
+        driver = str(config.get('driver', '')).lower()
+        if driver == 'sqlite':
+            import sqlite3
+            caminho = Path(config.get('database') or '')
+            if not config.get('database'):
+                raise MigrationError(f"datasource '{nome}' (sqlite) has no database: path")
+            if not caminho.is_absolute():
+                caminho = self.project_path / caminho
+            caminho.parent.mkdir(parents=True, exist_ok=True)
+            self._conn = sqlite3.connect(str(caminho))
+            self._db_type = 'sqlite'
+            logger.info("Migrating datasource %s (SQLite at %s)", nome, caminho)
             return self._conn
-
-        # Fallback to SQLite
-        logger.warning("PostgreSQL unavailable, falling back to SQLite")
-        if self._try_sqlite(config):
+        if driver in ('postgres', 'postgresql'):
+            try:
+                import psycopg2
+            except ImportError as exc:
+                raise MigrationError("datasource '%s' is PostgreSQL: pip install psycopg2-binary" % nome) from exc
+            self._conn = psycopg2.connect(
+                host=config.get('host', 'localhost'), port=int(config.get('port', 5432)),
+                dbname=config.get('database'), user=config.get('username') or config.get('user'),
+                password=config.get('password', ''), connect_timeout=5)
+            self._db_type = 'postgres'
+            logger.info("Migrating datasource %s (PostgreSQL %s)", nome, config.get('database'))
             return self._conn
+        raise MigrationError(f"datasource '{nome}': driver {driver!r} is not supported by quantum migrate "
+                             f"(use sqlite or postgres)")
 
-        raise MigrationError("Could not connect to any database")
-
-    def _load_config(self) -> Dict:
-        """Load database configuration from quantum.config.yaml"""
+    def _datasource_config(self):
         config_path = self.project_path / "quantum.config.yaml"
-        if not config_path.exists():
-            return {}
-
-        try:
+        datasources = {}
+        if config_path.exists():
             import yaml
-            with open(config_path) as f:
-                config = yaml.safe_load(f) or {}
-            return config.get('database', {})
-        except Exception as e:
-            logger.warning(f"Could not load config: {e}")
-            return {}
-
-    def _try_postgres(self, config: Dict) -> bool:
-        """Try to connect to PostgreSQL"""
-        try:
-            import psycopg2
-
-            # Get connection params from config or environment
-            host = config.get('host') or os.environ.get('QUANTUM_DB_HOST', 'localhost')
-            port = config.get('port') or os.environ.get('QUANTUM_DB_PORT', '5432')
-            database = config.get('database') or os.environ.get('QUANTUM_DB_NAME', 'quantum')
-            user = config.get('user') or os.environ.get('QUANTUM_DB_USER', 'postgres')
-            password = config.get('password') or os.environ.get('QUANTUM_DB_PASSWORD', '')
-
-            self._conn = psycopg2.connect(
-                host=host,
-                port=int(port),
-                database=database,
-                user=user,
-                password=password,
-                connect_timeout=5
-            )
-            self._db_type = 'postgres'
-            logger.info(f"Connected to PostgreSQL at {host}:{port}/{database}")
-            return True
-
-        except ImportError:
-            logger.debug("psycopg2 not installed")
-            return False
-        except Exception as e:
-            logger.debug(f"PostgreSQL connection failed: {e}")
-            return False
-
-    def _try_sqlite(self, config: Dict) -> bool:
-        """Try to connect to SQLite"""
-        try:
-            import sqlite3
-
-            db_path = config.get('sqlite_path') or self.project_path / "data" / "quantum.db"
-            db_path = Path(db_path)
-            db_path.parent.mkdir(parents=True, exist_ok=True)
-
-            self._conn = sqlite3.connect(str(db_path))
-            self._db_type = 'sqlite'
-            logger.info(f"Connected to SQLite at {db_path}")
-            return True
-
-        except Exception as e:
-            logger.error(f"SQLite connection failed: {e}")
-            return False
+            from quantum.core.config_env import expand_env
+            with open(config_path, encoding='utf-8') as f:
+                datasources = (expand_env(yaml.safe_load(f) or {}).get('datasources') or {})
+        if not datasources:
+            raise MigrationError(
+                "quantum.config.yaml declares no datasources. Add one, for example:\n"
+                "  datasources:\n    db:\n      driver: sqlite\n      database: ./data/app.db")
+        if self.datasource:
+            if self.datasource not in datasources:
+                raise MigrationError(f"no datasource '{self.datasource}'; declared: {', '.join(datasources)}")
+            return self.datasource, datasources[self.datasource]
+        if len(datasources) > 1:
+            raise MigrationError(f"several datasources are declared ({', '.join(datasources)}); "
+                                 f"choose one with --datasource")
+        nome = next(iter(datasources))
+        return nome, datasources[nome]
+
+    def _ensure_connected(self):
+        if self._conn is None:
+            self.connect()
 
     @property
     def db_type(self) -> str:
@@ -163,10 +144,10 @@ class MigrationRunner:
 
     MIGRATIONS_TABLE = "_migrations"
 
-    def __init__(self, project_path: Path = None):
+    def __init__(self, project_path: Path = None, datasource: str = None):
         self.project_path = project_path or Path.cwd()
         self.migrations_dir = self.project_path / "migrations"
-        self.db = DatabaseConnection(self.project_path)
+        self.db = DatabaseConnection(self.project_path, datasource)
 
     def _ensure_migrations_table(self):
         """Create migrations tracking table if it doesn't exist"""

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/quantum/cli/runner.py

@@ -25,7 +25,6 @@ from quantum.core.parser import QuantumParser, QuantumParseError
 from quantum.core.ast_nodes import ComponentNode, ApplicationNode, JobNode
 from quantum.runtime.component import ComponentRuntime, ComponentExecutionError
 from quantum.runtime.web_server import QuantumWebServer
-from quantum.runtime.api_server import QuantumAPIServer
 
 # Import deploy commands (lazy load to avoid import errors if requests not installed)
 def _get_deploy_module():
@@ -77,12 +76,15 @@ def load_config(config_path: str = 'quantum.config.yaml') -> dict:
     so `datasources:` declared in quantum.config.yaml were never seen and
     every q:query fell through to the optional Quantum Admin API.
     """
+    from quantum.core.config_env import ConfigEnvError, expand_env
     try:
         import yaml
         path = Path(config_path)
         if path.exists():
             with open(path, 'r', encoding='utf-8') as fh:
-                return yaml.safe_load(fh) or {}
+                return expand_env(yaml.safe_load(fh) or {})
+    except ConfigEnvError:
+        raise                   # CFG-1: never run with a half-read config
     except Exception as exc:
         print(f"[WARN] Could not read {config_path}: {exc}")
     return {}
@@ -175,6 +177,9 @@ class QuantumRunner:
             for route in app.routes:
                 print(f"     {route.method} {route.path}")
 
+        from quantum.core.tiers import warn_app_type
+        warn_app_type(app.app_type)
+
         if app.app_type == 'game':
             return self._build_game(app, debug)
         elif app.app_type == 'terminal':
@@ -184,10 +189,6 @@ class QuantumRunner:
         elif app.app_type == 'ui':
             target = getattr(self, '_ui_target', 'html')
             return self._build_ui(app, target, debug)
-        elif app.app_type == 'html':
-            return self._start_web_server(app)
-        elif app.app_type in ('microservices', 'api'):
-            return self._start_api_server(app)
         else:
             print(f"[ERROR] Application type '{app.app_type}' not supported")
             return 1
@@ -268,32 +269,6 @@ class QuantumRunner:
         # TODO: Implement real job execution
         print("[SUCCESS] Job executed successfully")
         return 0
-    
-    def _start_web_server(self, app: ApplicationNode) -> int:
-        """Start web server"""
-        try:
-            server = QuantumWebServer(port=8080)
-            server.configure_from_ast(app)
-            # Propagate the server's exit code: it returns non-zero when the
-            # port is taken or the bind fails, and swallowing that made
-            # `quantum run` report success with nothing listening.
-            return server.start() or 0
-        except Exception as e:
-            print(f"[ERROR] Web server error: {e}")
-            return 1
-    
-    def _start_api_server(self, app: ApplicationNode) -> int:
-        """Start API server"""
-        try:
-            server = QuantumAPIServer(port=8080)
-            server.configure_from_ast(app)
-            # Propagate the server's exit code: it returns non-zero when the
-            # port is taken or the bind fails, and swallowing that made
-            # `quantum run` report success with nothing listening.
-            return server.start() or 0
-        except Exception as e:
-            print(f"[ERROR] API server error: {e}")
-            return 1
 
 
 def main():
@@ -305,8 +280,6 @@ def main():
 Examples:
   quantum start                    # Start web server (magic!)
   quantum run hello.q              # Execute component
-  quantum run webapp.q             # Start web server from .q file
-  quantum run api.q                # Start API server
   quantum run game.q --engine godot # Build Godot 4 project
   quantum run backup-job.q         # Execute job
   quantum deploy ./my-app          # Deploy application
@@ -384,6 +357,7 @@ Examples:
 
     # Migration commands
     migrate_parser = subparsers.add_parser('migrate', help='Database migration commands')
+    migrate_parser.add_argument('--datasource', help='Datasource from quantum.config.yaml (default: the only one declared)')
     migrate_subparsers = migrate_parser.add_subparsers(dest='migrate_command')
 
     migrate_subparsers.add_parser('status', help='Show migration status')
@@ -488,7 +462,7 @@ Examples:
         MigrationRunner = result
 
         try:
-            runner = MigrationRunner()
+            runner = MigrationRunner(datasource=getattr(args, 'datasource', None))
 
             if args.migrate_command == 'status':
                 import json

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/quantum/core/ast_nodes.py

@@ -1919,6 +1919,7 @@ class DataNode(QuantumNode):
 
         # Result metadata
         self.result: Optional[str] = None
+        self.on_error: str = 'fail'   # DATA-4: 'fail' or 'continue'
 
         # Child elements
         self.columns: List[ColumnNode] = []

quantum_framework-0.11.0/quantum/core/config_env.py

@@ -0,0 +1,54 @@
+"""
+`${VAR}` in quantum.config.yaml (CFG-1).
+
+    datasources:
+      db:
+        password: ${DB_PASSWORD}
+        host: ${DB_HOST:-localhost}
+        port: ${DB_PORT:5432}      # ':' works as well as ':-'
+
+A config file is the place people put secrets by reference, and every loader
+used to read `${DB_PASSWORD}` as the literal password. There were four loaders
+(the CLI, the web server, the service container, migrations); they all go
+through expand_env now.
+"""
+
+import os
+import re
+from typing import Any
+
+_REFERENCE = re.compile(r'\$\$|\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-?([^}]*))?\}')
+
+
+class ConfigEnvError(ValueError):
+    """A `${VAR}` with no value and no default."""
+
+
+def expand_env(value: Any, path: str = '') -> Any:
+    """Replace `${NAME}` and `${NAME:-default}` in every string of a loaded config.
+
+    `$$` is a literal `$`. A variable that is not set and has no default is an
+    error naming the variable and where it was used — an empty password or
+    database path would otherwise fail much later, somewhere else.
+    """
+    if isinstance(value, dict):
+        return {k: expand_env(v, f'{path}.{k}' if path else str(k)) for k, v in value.items()}
+    if isinstance(value, list):
+        return [expand_env(v, f'{path}[{i}]') for i, v in enumerate(value)]
+    if not isinstance(value, str) or '$' not in value:
+        return value
+
+    def substitute(match):
+        if match.group(0) == '$$':
+            return '$'
+        name, default = match.group(1), match.group(2)
+        if name in os.environ:
+            return os.environ[name]
+        if default is not None:
+            return default
+        raise ConfigEnvError(
+            f"quantum.config.yaml: {path or 'value'} uses ${{{name}}}, but the "
+            f"environment variable {name} is not set. Set it, or give a default: "
+            f"${{{name}:-value}}")
+
+    return _REFERENCE.sub(substitute, value)

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/quantum/core/expression_stdlib.py

@@ -118,7 +118,41 @@ def _round(v: Any, digits: int = 0) -> Any:
     return int(result) if digits == 0 else result
 
 
+# -- passwords ---------------------------------------------------------------
+#
+# Authentication is Core (decision D4), and a login is "look the user up, then
+# check the password". Without these, a .q could not check a password against
+# a stored hash without q:python — so every login example just set
+# session.authenticated=true for whoever submitted the form (gap AUTH-1).
+
+def hash_password(password: Any) -> str:
+    """bcrypt hash of a password, for storing. Never store the password itself."""
+    import bcrypt
+    if password is None or password == '':
+        raise ValueError("hashPassword: the password is empty")
+    return bcrypt.hashpw(str(password).encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+
+def verify_password(password: Any, hashed: Any) -> bool:
+    """True when `password` matches a hash made by hashPassword.
+
+    Fail-closed: an empty password, a missing hash or a malformed hash is
+    False, never an error — so `q:if condition="verifyPassword(senha, h)"`
+    cannot be tricked into the true branch by bad data.
+    """
+    import bcrypt
+    if not password or not hashed or not isinstance(hashed, str):
+        return False
+    try:
+        return bcrypt.checkpw(str(password).encode('utf-8'), hashed.encode('utf-8'))
+    except (ValueError, TypeError):
+        return False
+
+
 STDLIB = {
+    # passwords
+    'hashPassword': hash_password,
+    'verifyPassword': verify_password,
     # dates
     'now': now,
     'dateAdd': date_add,

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/quantum/core/expressions.py

@@ -35,6 +35,15 @@ class ExpressionError(Exception):
     """Raised when an expression cannot be evaluated."""
 
 
+class UndefinedError(ExpressionError):
+    """A name, key or attribute that does not exist.
+
+    Kept apart from the other failures because a condition is a presence test
+    (EXPR-5): `<q:if condition="flash">` is false before there is a flash, but
+    `a === b` or a misspelled function is still an error.
+    """
+
+
 # `{n}`, `{n,}` and `{n,m}` are regex quantifiers, not Quantum expressions.
 # They occur for real: examples/form_validation.q has pattern="\d{10,11}" and
 # examples/python-scripting.q has r'[a-zA-Z]{2,}'. The old evaluator left them
@@ -51,9 +60,9 @@ _REGEX_QUANTIFIER = re.compile(r'^\d+\s*(,\s*\d*)?$')
 def is_regex_quantifier(content: str) -> bool:
     """True when a `{...}` group should be left as literal text.
 
-    Note this also catches a bare `{5}` meant as the number 5 — ambiguous by
-    construction, and resolved in favour of not corrupting regexes. It matches
-    what the engine already did, so nothing changes for existing templates.
+    A q: attribute that is ONLY `{5}` is the number 5 (EXPR-7) — the runtime
+    checks that case before calling this. Inside other text, `[0-9]{3}` stays a
+    quantifier.
     """
     return bool(_REGEX_QUANTIFIER.match(content.strip()))
 
@@ -148,14 +157,12 @@ def _suggest(wanted: str, target: Any, limit: int = 3) -> str:
 #
 #   {9**9**9}          -> does not return
 #   {10**100000000}    -> does not return
-#   {'a' * 999999999}  -> allocates ~1 GB and returns
+#   ({'a' * 999999999} allocated ~1 GB; since EXPR-7 `*` needs numbers.)
 #
 # No dunder, no escape, no attacker — a typo in a template is enough, and there
 # is no timeout anywhere above this to catch it. The caps are far above any
-# real expression: 4096 bits is a 1233-digit number, and 10 MB of repeated
-# string is already absurd for a page.
+# real expression: 4096 bits is a 1233-digit number.
 _MAX_POW_BITS = 4096
-_MAX_REPEAT = 10_000_000
 
 
 def _guard_pow(left: Any, right: Any) -> None:
@@ -193,31 +200,24 @@ def _guard_pow(left: Any, right: Any) -> None:
         )
 
 
-def _guard_repeat(left: Any, right: Any) -> None:
-    for seq, count in ((left, right), (right, left)):
-        if isinstance(seq, (str, bytes, list, tuple)) and isinstance(count, int) \
-                and not isinstance(count, bool):
-            if len(seq) * max(count, 0) > _MAX_REPEAT:
-                raise ExpressionError(
-                    f"repeating a {len(seq)}-item sequence {count} times "
-                    f"exceeds {_MAX_REPEAT}; this would exhaust memory"
-                )
-
-
 def _both_numeric(left: Any, right: Any) -> bool:
     return isinstance(left, (int, float)) and isinstance(right, (int, float)) \
         and not isinstance(left, bool) and not isinstance(right, bool)
 
 
 
-def _normalise_not(source: str) -> str:
-    """Rewrite JavaScript-style `!x` negation into Python's `not x`.
+def _normalise_js_operators(source: str) -> str:
+    """Rewrite JavaScript-style `!x`, `a && b` and `a || b` into Python's
+    `not`, `and` and `or`.
 
-    Real .q files use it ({!result.success} appears across the examples), so it
-    is part of the language surface whether or not it was ever specified. `!=`
-    is left alone, and `!` inside a string literal is not touched.
+    Real .q files use them ({!result.success} appears across the examples, and
+    docs/guide/conditionals.md teaches `age >= 18 && hasLicense`), so they are
+    part of the language surface. `&&` and `||` were never translated: the
+    condition failed to parse and, read as false, took the else branch for
+    every input. `!=` is left alone, and nothing inside a string literal is
+    touched.
     """
-    if '!' not in source:
+    if '!' not in source and '&&' not in source and '||' not in source:
         return source
 
     out = []
@@ -240,6 +240,10 @@ def _normalise_not(source: str) -> str:
             out.append('not ')
             i += 1
             continue
+        if source[i:i + 2] in ('&&', '||'):
+            out.append(' and ' if ch == '&' else ' or ')
+            i += 2
+            continue
         out.append(ch)
         i += 1
     return ''.join(out)
@@ -281,7 +285,7 @@ class ExpressionEvaluator:
         if len(source) > self.max_length:
             raise ExpressionError(f"expression exceeds {self.max_length} characters")
 
-        source = _normalise_not(source)
+        source = _normalise_js_operators(source)
 
         try:
             tree = ast.parse(source, mode='eval')
@@ -374,12 +378,27 @@ class ExpressionEvaluator:
             cl, cr = coerce_number(left), coerce_number(right)
             if _both_numeric(cl, cr):
                 left, right = cl, cr
+            elif isinstance(node.op, ast.Add) and not (
+                    (isinstance(left, str) and isinstance(right, str))
+                    or (isinstance(left, list) and isinstance(right, list))):
+                # EXPR-7: '+' adds numbers or joins two texts / two lists. The
+                # mixed case used to surface Python's "can only concatenate
+                # str (not "int") to str".
+                raise ExpressionError(
+                    f"'+' needs two numbers, two texts or two lists, got {left!r} and {right!r}")
+            elif not isinstance(node.op, ast.Add):
+                # EXPR-7: arithmetic is on numbers. Python would repeat text
+                # ('ab' * 3), format it ('%s' % x) or fail with its own
+                # message; `n * factorial(n - 1)` whose base case returned the
+                # text '{1}' produced '{1}{1}{1}{1}{1}' and no error.
+                simbolo = {ast.Sub: '-', ast.Mult: '*', ast.Div: '/', ast.FloorDiv: '//',
+                           ast.Mod: '%', ast.Pow: '**'}[type(node.op)]
+                raise ExpressionError(
+                    f"'{simbolo}' needs two numbers, got {left!r} and {right!r}")
 
             # Refuse what would not finish, before attempting it.
             if isinstance(node.op, ast.Pow):
                 _guard_pow(left, right)
-            elif isinstance(node.op, ast.Mult):
-                _guard_repeat(left, right)
 
             try:
                 return op(left, right)
@@ -467,7 +486,9 @@ class ExpressionEvaluator:
                 if isinstance(target, dict):
                     return target.get(key)
                 return target[key]
-            except (IndexError, KeyError, TypeError) as exc:
+            except (IndexError, KeyError) as exc:
+                raise UndefinedError(f"cannot index: {exc}") from exc
+            except TypeError as exc:
                 raise ExpressionError(f"cannot index: {exc}") from exc
 
         if isinstance(node, ast.Dict):
@@ -513,7 +534,7 @@ class ExpressionEvaluator:
             return False
         if name == 'null':
             return None
-        raise ExpressionError(
+        raise UndefinedError(
             f"variable {name!r} is not defined{_suggest(name, ctx)}"
         )
 
@@ -521,7 +542,7 @@ class ExpressionEvaluator:
         if isinstance(target, dict):
             if attr in target:
                 return target[attr]
-            raise ExpressionError(
+            raise UndefinedError(
                 f"key {attr!r} not found{_suggest(attr, target)}"
             )
         if isinstance(target, (list, tuple, str)) and attr == 'length':
@@ -560,7 +581,7 @@ class ExpressionEvaluator:
                 f"{attr!r}; use .length for the count, or the query's "
                 f"<name>_result for its metadata"
             )
-        raise ExpressionError(
+        raise UndefinedError(
             f"attribute {attr!r} not found on {type(target).__name__}"
             f"{_suggest(attr, target)}"
         )

{quantum_framework-0.9.1 → quantum_framework-0.11.0}/quantum/core/features/data_import/src/ast_node.py

@@ -38,6 +38,7 @@ class DataNode(QuantumNode):
 
         # Result metadata
         self.result = None            # Variable name for metadata
+        self.on_error = 'fail'        # DATA-4: 'fail' or 'continue'
 
     def add_column(self, column: 'ColumnNode'):
         """Add CSV column definition"""