qubasic 0.6.0__tar.gz → 0.6.3__tar.gz

{qubasic-0.6.0 → qubasic-0.6.3}/CHANGELOG.md

@@ -1,8 +1,29 @@
 # Changelog
 
+## 0.6.3 (2026-06-18)
+
+### Fixed
+- Colon-compound `@register` lines in LOCC mode now apply every gate. `@A H 0 : @A CX 0,1` (and the inherited form `@A H 0 : CX 0,1`) were captured as a single statement and mis-tokenized, so all but the first gate were silently dropped. The parser now splits them into per-statement parts with register inheritance, and the immediate-mode REPL path does the same.
+- `SAVE_EXPECT`, `SAVE_PROBS`, and `SAVE_AMPS` no longer overwrite their target variable with 0 at circuit-build time. The placeholder keeps any prior value, so a program that re-runs with the SAVE line still present can read the previous result during the build pass (the post-run extraction then fills in the fresh value).
+- `PRINT` honors `;` and `,` between multiple items: `PRINT "S ="; x` concatenates and `PRINT a, b` advances to the next 14-column zone. Separators inside quoted strings and inside call parentheses (`PRINT LEFT$(s$, 3)`) are no longer treated as item breaks.
+- `PRINT` variable substitution no longer rewrites identifiers inside quoted string literals, so a label such as `PRINT "value of S"` is emitted verbatim even when `S` is a defined variable.
+
+## 0.6.2 (2026-06-18)
+
+### Fixed
+- Changing the qubit count after a run (via `QUBITS n` or `POKE $D000`) now invalidates the cached statevector, so `MAP`, a `PEEK` of the qubit-state block, and `BLOCH` no longer reshape a stale statevector to the new qubit count and crash.
+
+## 0.6.1 (2026-06-18)
+
+### Fixed
+- Changing noise strength between runs (for example `NOISE amplitude_damping 0.1` then `0.9`) now rebuilds the circuit instead of reusing the first noise level, so sequential noise comparisons are correct.
+
+### Changed
+- The CLI now lives in `qubasic_core/cli.py`; the `qubasic` console script and `python -m qubasic_core` are unchanged, but the former top-level `qubasic` module is removed. Test suites moved under `tests/`.
+
 ## 0.6.0 (2026-06-18)
 
-Correctness, scalability, and usability pass (61 fixes).
+Correctness, scalability, and usability improvements.
 
 ### Fixed
 - **Time-travel debugging now works**: STEP records statevector checkpoints, so REWIND/FORWARD/HISTORY operate (previously `_checkpoint_sv` was never called).

{qubasic-0.6.0/qubasic.egg-info → qubasic-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.0
+Version: 0.6.3
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -73,11 +73,12 @@ Requires Python >= 3.10, Qiskit >= 1.0, qiskit-aer >= 0.13.
 ## Usage
 
 ```
-python qubasic.py                  Interactive REPL
-python qubasic.py script.qb        Run a script file
-python qubasic.py --quiet script    Suppress banner, output results only
-python qubasic.py --json script     Machine-readable JSON output
-python qubasic.py --help            Show CLI help
+qubasic                       Interactive REPL (installed console script)
+python -m qubasic_core         Same, without installing
+qubasic script.qb             Run a script file
+qubasic --quiet script         Suppress banner, output results only
+qubasic --json script          Machine-readable JSON output
+qubasic --help                Show CLI help
 ```
 
 Headless (no REPL):
@@ -685,7 +686,7 @@ Programs with SEND use prefix/suffix splitting: the deterministic prefix (before
 ## JSON output
 
 ```
-python qubasic.py --json examples/bell.qb
+qubasic --json examples/bell.qb
 ```
 
 ```json
@@ -699,8 +700,9 @@ python qubasic.py --json examples/bell.qb
 ## Architecture
 
 ```
-qubasic.py              CLI entry point
 qubasic_core/
+  cli.py                 CLI entry point (qubasic / python -m qubasic_core)
+  __main__.py            Module entry point
   engine_state.py        Engine: standalone state container
   terminal.py            QBasicTerminal: REPL + command dispatch
   engine.py              Constants, gate tables, numpy simulation, LOCCEngine
@@ -729,6 +731,8 @@ qubasic_core/
   demos.py               Built-in demo circuits
   protocol.py            TerminalProtocol (mixin contract)
   mock_backend.py        MockAerSimulator for fast testing
+tests/                   Test suites (test_qubasic.py, test_features.py)
+examples/                Sample .qb programs
 ```
 
 `Engine` holds all program state. `QBasicTerminal` inherits `Engine` + 20 mixins. Execution methods live on `QBasicTerminal`, so headless/agent use should instantiate `QBasicTerminal` (the `Engine` base is a state container only).

{qubasic-0.6.0 → qubasic-0.6.3}/README.md

@@ -40,11 +40,12 @@ Requires Python >= 3.10, Qiskit >= 1.0, qiskit-aer >= 0.13.
 ## Usage
 
 ```
-python qubasic.py                  Interactive REPL
-python qubasic.py script.qb        Run a script file
-python qubasic.py --quiet script    Suppress banner, output results only
-python qubasic.py --json script     Machine-readable JSON output
-python qubasic.py --help            Show CLI help
+qubasic                       Interactive REPL (installed console script)
+python -m qubasic_core         Same, without installing
+qubasic script.qb             Run a script file
+qubasic --quiet script         Suppress banner, output results only
+qubasic --json script          Machine-readable JSON output
+qubasic --help                Show CLI help
 ```
 
 Headless (no REPL):
@@ -652,7 +653,7 @@ Programs with SEND use prefix/suffix splitting: the deterministic prefix (before
 ## JSON output
 
 ```
-python qubasic.py --json examples/bell.qb
+qubasic --json examples/bell.qb
 ```
 
 ```json
@@ -666,8 +667,9 @@ python qubasic.py --json examples/bell.qb
 ## Architecture
 
 ```
-qubasic.py              CLI entry point
 qubasic_core/
+  cli.py                 CLI entry point (qubasic / python -m qubasic_core)
+  __main__.py            Module entry point
   engine_state.py        Engine: standalone state container
   terminal.py            QBasicTerminal: REPL + command dispatch
   engine.py              Constants, gate tables, numpy simulation, LOCCEngine
@@ -696,6 +698,8 @@ qubasic_core/
   demos.py               Built-in demo circuits
   protocol.py            TerminalProtocol (mixin contract)
   mock_backend.py        MockAerSimulator for fast testing
+tests/                   Test suites (test_qubasic.py, test_features.py)
+examples/                Sample .qb programs
 ```
 
 `Engine` holds all program state. `QBasicTerminal` inherits `Engine` + 20 mixins. Execution methods live on `QBasicTerminal`, so headless/agent use should instantiate `QBasicTerminal` (the `Engine` base is a state container only).

{qubasic-0.6.0 → qubasic-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qubasic"
-version = "0.6.0"
+version = "0.6.3"
 description = "Quantum BASIC Interactive Terminal"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -42,10 +42,9 @@ charts = ["plotille>=5.0"]
 readline = ["pyreadline3>=3.4; sys_platform == 'win32'"]
 
 [project.scripts]
-qubasic = "qubasic:main"
+qubasic = "qubasic_core.cli:main"
 
 [tool.setuptools]
-py-modules = ["qubasic"]
 packages = ["qubasic_core"]
 
 [tool.setuptools.package-data]
@@ -66,9 +65,19 @@ skip_empty = true
 
 [tool.mypy]
 python_version = "3.10"
-warn_return_any = true
+ignore_missing_imports = true
 warn_unused_configs = true
-disallow_untyped_defs = true
-check_untyped_defs = true
 warn_redundant_casts = true
-warn_unused_ignores = true
+# QBasicTerminal composes 20 mixins; each mixin accesses attributes the host
+# class provides, which mypy cannot resolve in isolation. The codebase is
+# intentionally gradually typed, so the strict per-method settings and the
+# cross-mixin attribute check are disabled while keeping mypy useful for real
+# type mismatches, undefined names, and signature checks.
+disallow_untyped_defs = false
+check_untyped_defs = false
+warn_return_any = false
+warn_unused_ignores = false
+# attr-defined: cross-mixin attributes the host class provides.
+# has-type: types behind the lazy __getattr__ re-exports cannot be inferred.
+# misc/union-attr: mixin base-class attribute overlap and optional access.
+disable_error_code = ["attr-defined", "has-type", "misc", "union-attr"]

{qubasic-0.6.0 → qubasic-0.6.3/qubasic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qubasic
-Version: 0.6.0
+Version: 0.6.3
 Summary: Quantum BASIC Interactive Terminal
 Author-email: "Charles C. Norton" <machineelv@gmail.com>
 License-Expression: MIT
@@ -73,11 +73,12 @@ Requires Python >= 3.10, Qiskit >= 1.0, qiskit-aer >= 0.13.
 ## Usage
 
 ```
-python qubasic.py                  Interactive REPL
-python qubasic.py script.qb        Run a script file
-python qubasic.py --quiet script    Suppress banner, output results only
-python qubasic.py --json script     Machine-readable JSON output
-python qubasic.py --help            Show CLI help
+qubasic                       Interactive REPL (installed console script)
+python -m qubasic_core         Same, without installing
+qubasic script.qb             Run a script file
+qubasic --quiet script         Suppress banner, output results only
+qubasic --json script          Machine-readable JSON output
+qubasic --help                Show CLI help
 ```
 
 Headless (no REPL):
@@ -685,7 +686,7 @@ Programs with SEND use prefix/suffix splitting: the deterministic prefix (before
 ## JSON output
 
 ```
-python qubasic.py --json examples/bell.qb
+qubasic --json examples/bell.qb
 ```
 
 ```json
@@ -699,8 +700,9 @@ python qubasic.py --json examples/bell.qb
 ## Architecture
 
 ```
-qubasic.py              CLI entry point
 qubasic_core/
+  cli.py                 CLI entry point (qubasic / python -m qubasic_core)
+  __main__.py            Module entry point
   engine_state.py        Engine: standalone state container
   terminal.py            QBasicTerminal: REPL + command dispatch
   engine.py              Constants, gate tables, numpy simulation, LOCCEngine
@@ -729,6 +731,8 @@ qubasic_core/
   demos.py               Built-in demo circuits
   protocol.py            TerminalProtocol (mixin contract)
   mock_backend.py        MockAerSimulator for fast testing
+tests/                   Test suites (test_qubasic.py, test_features.py)
+examples/                Sample .qb programs
 ```
 
 `Engine` holds all program state. `QBasicTerminal` inherits `Engine` + 20 mixins. Execution methods live on `QBasicTerminal`, so headless/agent use should instantiate `QBasicTerminal` (the `Engine` base is a state container only).

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
-qubasic.py
 examples/bell.qb
 examples/grover3.qb
 examples/locc_teleport.qb
@@ -19,6 +18,7 @@ qubasic_core/__main__.py
 qubasic_core/analysis.py
 qubasic_core/backend.py
 qubasic_core/classic.py
+qubasic_core/cli.py
 qubasic_core/control_flow.py
 qubasic_core/debug.py
 qubasic_core/demos.py
@@ -54,4 +54,6 @@ qubasic_core/statements.py
 qubasic_core/strings.py
 qubasic_core/subs.py
 qubasic_core/sweep.py
-qubasic_core/terminal.py
+qubasic_core/terminal.py
+tests/test_features.py
+tests/test_qubasic.py

qubasic-0.6.3/qubasic.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qubasic = qubasic_core.cli:main

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic.egg-info/top_level.txt

@@ -1,2 +1 @@
-qubasic
 qubasic_core

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/__init__.py

@@ -28,7 +28,7 @@ __all__ = [
     'GATE_TABLE', 'GATE_ALIASES',
 ]
 
-__version__ = '0.6.0'
+__version__ = '0.6.3'
 
 def __getattr__(name):
     """Lazy import heavy modules on first access."""

qubasic-0.6.3/qubasic_core/__main__.py

@@ -0,0 +1,6 @@
+"""Run the CLI as a module: python -m qubasic_core [args]."""
+
+from qubasic_core.cli import main
+
+if __name__ == '__main__':
+    main()

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/analysis.py

@@ -182,7 +182,7 @@ class AnalysisMixin:
             return
         n = self._active_nqubits
         sv = np.ascontiguousarray(sv).ravel()
-        checks = []
+        checks: list = []
 
         # 1. SV normalization
         norm = float(np.sum(np.abs(sv)**2))

qubasic-0.6.0/qubasic.py → qubasic-0.6.3/qubasic_core/cli.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 """
-QUBASIC — Quantum BASIC Interactive Terminal
+QUBASIC — command-line entry point.
 
 Usage:
-    python qubasic.py             Interactive REPL
-    python qubasic.py script.qb   Run a script file
+    qubasic                       Interactive REPL (installed console script)
+    python -m qubasic_core        Same, run as a module
+    qubasic script.qb             Run a script file
 """
 
 import sys

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/control_flow.py

@@ -63,46 +63,86 @@ class ControlFlowMixin:
         self.variables[name] = val
         return True, ExecResult.ADVANCE
 
-    def _cf_print(self, stmt: str, run_vars: dict[str, Any],
-                  parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
-        raw_expr = parsed.expr
-        text = self._substitute_vars(raw_expr.strip(), run_vars)
-        # Determine trailing separator: ; suppresses newline, , advances to tab
-        suppress_newline = raw_expr.rstrip().endswith(';')
-        tab_advance = raw_expr.rstrip().endswith(',')
-        if suppress_newline:
-            text = text.rstrip().removesuffix(';').rstrip()
-        elif tab_advance:
-            text = text.rstrip().removesuffix(',').rstrip()
-        # Evaluate SPC(n) and TAB(n) inline
-        def _replace_spc(m_spc):
-            n = int(self._eval_with_vars(m_spc.group(1), run_vars))
-            return ' ' * max(0, n)
-        def _replace_tab(m_tab):
-            n = int(self._eval_with_vars(m_tab.group(1), run_vars))
-            return ' ' * max(0, n)
-        text = re.sub(r'\bSPC\s*\(([^)]+)\)', _replace_spc, text, flags=re.IGNORECASE)
-        text = re.sub(r'\bTAB\s*\(([^)]+)\)', _replace_tab, text, flags=re.IGNORECASE)
-        # Evaluate the expression
-        if (text.startswith('"') and text.endswith('"')) or \
-           (text.startswith("'") and text.endswith("'")):
-            output = text[1:-1]
-        else:
+    @staticmethod
+    def _split_print_items(expr: str) -> list[tuple[str, str]]:
+        """Split a PRINT argument list into (item, trailing-separator) pairs.
+
+        ';' and ',' are recognized only at top level (outside quotes and
+        parentheses/brackets), so PRINT LEFT$(s$, 3) stays one item and a comma
+        inside a quoted literal is preserved. The separator recorded with each
+        item is the one that follows it; '' marks the final item / no trailing
+        separator.
+        """
+        items: list[tuple[str, str]] = []
+        buf = ''
+        depth = 0
+        quote: str | None = None
+        for ch in expr:
+            if quote:
+                buf += ch
+                if ch == quote:
+                    quote = None
+            elif ch in ('"', "'"):
+                quote = ch
+                buf += ch
+            elif ch in '([':
+                depth += 1
+                buf += ch
+            elif ch in ')]':
+                depth = max(0, depth - 1)
+                buf += ch
+            elif ch in ';,' and depth == 0:
+                items.append((buf.strip(), ch))
+                buf = ''
+            else:
+                buf += ch
+        if buf.strip():
+            items.append((buf.strip(), ''))
+        return items
+
+    def _eval_print_item(self, item: str, run_vars: dict[str, Any]) -> str:
+        """Evaluate a single PRINT item to its display string."""
+        item = item.strip()
+        if not item:
+            return ''
+        # Quoted literal: emit verbatim (no substitution, no SPC/TAB).
+        if (item[0] == '"' and item[-1] == '"') or (item[0] == "'" and item[-1] == "'"):
+            return item[1:-1]
+        text = self._substitute_vars(item, run_vars)
+
+        def _spaces(m):
             try:
-                ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else dict(run_vars) if not isinstance(run_vars, dict) else run_vars
-                result = self._safe_eval(text, extra_ns=ns)
-                output = str(result)
+                return ' ' * max(0, int(self._eval_with_vars(m.group(1), run_vars)))
             except Exception:
-                output = text
-        # Output with separator behavior
-        if suppress_newline:
-            self.io.write(output)
-        elif tab_advance:
-            col = len(output) % 14
-            padding = 14 - col if col > 0 else 14
-            self.io.write(output + ' ' * padding)
+                return ''
+        text = re.sub(r'\bSPC\s*\(([^)]+)\)', _spaces, text, flags=re.IGNORECASE)
+        text = re.sub(r'\bTAB\s*\(([^)]+)\)', _spaces, text, flags=re.IGNORECASE)
+        if not text.strip():
+            return text                      # standalone SPC/TAB -> whitespace
+        try:
+            ns = run_vars.as_dict() if hasattr(run_vars, 'as_dict') else (
+                run_vars if isinstance(run_vars, dict) else dict(run_vars))
+            return str(self._safe_eval(text, extra_ns=ns))
+        except Exception:
+            return text
+
+    def _cf_print(self, stmt: str, run_vars: dict[str, Any],
+                  parsed: PrintStmt) -> tuple[bool, ExecOutcome]:
+        items = self._split_print_items(parsed.expr)
+        if not items:
+            self.io.writeln('')             # bare PRINT -> blank line
+            return True, ExecResult.ADVANCE
+        out = ''
+        for item, sep in items:
+            out += self._eval_print_item(item, run_vars)
+            if sep == ',':                  # advance to next 14-column zone
+                col = len(out) % 14
+                out += ' ' * (14 - col if col else 14)
+        # A trailing ';' or ',' suppresses the newline (cursor stays on line).
+        if items[-1][1] in (';', ','):
+            self.io.write(out)
         else:
-            self.io.writeln(output)
+            self.io.writeln(out)
         return True, ExecResult.ADVANCE
 
     def _cf_goto(self, stmt: str, sorted_lines: list[int],

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/engine.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from enum import Enum, auto
+from typing import Any
 import numpy as np
 from qubasic_core.patterns import (
     RE_LINE_NUM, RE_DEF_SINGLE, RE_DEF_BEGIN, RE_REG_INDEX,
@@ -79,7 +80,7 @@ try:
     from rich.panel import Panel as _RichPanel
     from rich.text import Text as _RichText
     _RICH = True
-    _console = _RichConsole(highlight=False)
+    _console: Any = _RichConsole(highlight=False)
 except ImportError:
     _RICH = False
     _console = None

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/engine_state.py

@@ -71,6 +71,7 @@ class Engine:
         self._circuit_cache_key: Any = None
         self._circuit_cache: Any = None
         self._pending_set_state: Any = None  # immediate SET_STATE for next RUN
+        self._poke_state_prep: dict[Any, Any] = {}  # qubit prep from POKE $0100
 
         # LOCC
         self.locc: Any = None
@@ -118,3 +119,17 @@ class Engine:
         self._circuit_cache = None
         self._pending_set_state = None
         self._poke_state_prep = {}
+
+    def _invalidate_run_state(self) -> None:
+        """Drop cached results that describe a now-stale configuration.
+
+        Called when the qubit count changes: last_sv, last_counts,
+        last_circuit, and the transpile cache all assume the previous
+        num_qubits, so reading them afterwards would mislabel (or, for
+        the reshape in _peek_qubit/_bloch_vector, crash) the state.
+        """
+        self.last_counts = None
+        self.last_sv = None
+        self.last_circuit = None
+        self._circuit_cache_key = None
+        self._circuit_cache = None

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/exec_context.py

@@ -12,7 +12,7 @@ class ExecContext:
 
     sorted_lines: list[int]
     ip: int
-    run_vars: dict[str, Any]
+    run_vars: Any  # dict[str, Any] or a Scope wrapper
     loop_stack: list[dict[str, Any]] = field(default_factory=list)
     iteration_count: int = 0
     max_iterations: int = 100_000

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/executor.py

@@ -328,20 +328,42 @@ class ExecutorMixin:
             set(self.subroutines.keys()) |
             set(self._custom_gates.keys())
         )
-        # Tokenize: split on word boundaries, preserving delimiters
-        tokens = re.split(r'(\b\w+\b)', stmt)
-        for i, tok in enumerate(tokens):
-            if not tok or not tok[0].isalpha():
-                continue
-            if tok in protected or tok.upper() in protected or tok.lower() in protected:
-                continue
-            if tok in merged:
-                # Don't expand record bases (dicts) — leave p in p.x intact so
-                # the expression evaluator can resolve the field.
-                if isinstance(merged[tok], dict):
+
+        def _sub_segment(seg: str) -> str:
+            # Tokenize: split on word boundaries, preserving delimiters
+            tokens = re.split(r'(\b\w+\b)', seg)
+            for i, tok in enumerate(tokens):
+                if not tok or not tok[0].isalpha():
+                    continue
+                if tok in protected or tok.upper() in protected or tok.lower() in protected:
                     continue
-                tokens[i] = str(merged[tok])
-        return ''.join(tokens)
+                if tok in merged:
+                    # Don't expand record bases (dicts) — leave p in p.x intact
+                    # so the expression evaluator can resolve the field.
+                    if isinstance(merged[tok], dict):
+                        continue
+                    tokens[i] = str(merged[tok])
+            return ''.join(tokens)
+
+        # Substitute only outside quoted string literals: a variable named in a
+        # PRINT label (PRINT "S ="; S) must survive verbatim inside the quotes.
+        out: list[str] = []
+        i, n = 0, len(stmt)
+        while i < n:
+            ch = stmt[i]
+            if ch in ('"', "'"):
+                j = i + 1
+                while j < n and stmt[j] != ch:
+                    j += 1
+                out.append(stmt[i:j + 1])           # quoted span, verbatim
+                i = j + 1
+            else:
+                j = i
+                while j < n and stmt[j] not in ('"', "'"):
+                    j += 1
+                out.append(_sub_segment(stmt[i:j]))  # unquoted span
+                i = j
+        return ''.join(out)
 
     def _expand_statement(self, stmt, _call_stack: set[str] | None = None):
         """Expand subroutines. Returns list of gate strings.
@@ -636,18 +658,24 @@ class ExecutorMixin:
 
         Uses the same _exec_line pipeline as cmd_run for consistency.
         """
-        # In LOCC mode, handle @register prefix via the numpy engine
-        if self.locc_mode and self.locc:
-            m = RE_AT_REG_LINE.match(line)
-            if m:
+        # In LOCC mode, handle @register prefix via the numpy engine. Split
+        # colon-compound @REG lines so each gate is applied (a single @REG line
+        # is just the one-part case); a bare @REG line keeps prior behavior.
+        if self.locc_mode and self.locc and line.strip().startswith('@'):
+            parts = self._split_colon_stmts(line) if ':' in line else [line.strip()]
+            for part in parts:
+                m = RE_AT_REG_LINE.match(part)
+                if not m:
+                    self.io.writeln(f"?BAD @register statement: {part}")
+                    continue
                 reg = m.group(1).upper()
                 gate_stmt = m.group(2).strip()
                 if reg not in self.locc.names:
                     self.io.writeln(f"?UNKNOWN REGISTER: {reg} (have {', '.join(self.locc.names)})")
                     return
                 self._locc_apply_gate(reg, gate_stmt)
-                self._locc_state()
-                return
+            self._locc_state()
+            return
         if line.strip().startswith('@'):
             self.io.writeln("?@register syntax requires LOCC mode (try: LOCC <n1> <n2>)")
             return

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/expression.py

@@ -116,7 +116,7 @@ class ExpressionMixin:
         'SQRT2': math.sqrt(2), 'sqrt2': math.sqrt(2),
         'True': True, 'False': False,
     }
-    _AST_OPS = {
+    _AST_OPS: dict[type, Any] = {
         ast.Add: operator.add, ast.Sub: operator.sub,
         ast.Mult: operator.mul, ast.Div: operator.truediv,
         ast.FloorDiv: operator.floordiv, ast.Mod: operator.mod,

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/file_io.py

@@ -6,6 +6,7 @@ import os
 import re
 import sys
 from pathlib import Path
+from typing import Any
 
 import numpy as np
 
@@ -99,7 +100,7 @@ class FileIOMixin:
                     else:
                         f.write(f"LET {name} = {val}\n")
                 # Save program (exclude lines injected by IMPORT)
-                imported = getattr(self, '_imported_lines', set())
+                imported: set[int] = getattr(self, '_imported_lines', set())
                 saved = [n for n in sorted(self.program.keys()) if n not in imported]
                 for num in saved:
                     f.write(f"{num} {self.program[num]}\n")

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/gates.py

@@ -242,8 +242,8 @@ def _measure_np(
     """
     sv = np.ascontiguousarray(sv).reshape([2] * n_qubits)
     ax = n_qubits - 1 - qubit
-    idx_0 = [slice(None)] * n_qubits
-    idx_1 = [slice(None)] * n_qubits
+    idx_0: list = [slice(None)] * n_qubits
+    idx_1: list = [slice(None)] * n_qubits
     idx_0[ax] = 0
     idx_1[ax] = 1
     p0 = float(np.sum(np.abs(sv[tuple(idx_0)])**2))

{qubasic-0.6.0 → qubasic-0.6.3}/qubasic_core/locc_engine.py

@@ -42,7 +42,7 @@ class LOCCEngine:
         self.joint = joint
         self.noise_param = noise_param
         self.noise_type = noise_type
-        self.classical = {}
+        self.classical: dict[str, int] = {}
         # Precompute offsets for JOINT mode
         self.offsets = []
         off = 0
@@ -237,8 +237,8 @@ class LOCCEngine:
         """Sample and return (per_reg_counts, joint_counts)."""
         if self.joint:
             raw = _sample_np(self.sv, self.n_total, shots)
-            per_reg = {name: {} for name in self.names}
-            joint = {}
+            per_reg: dict[str, dict[str, int]] = {name: {} for name in self.names}
+            joint: dict[str, int] = {}
             for state, count in raw.items():
                 # Split the joint bitstring into per-register segments.
                 # The joint statevector is ordered A[0..nA-1] B[0..nB-1] ...