quantum-framework 0.20.0__tar.gz → 0.22.0__tar.gz

{quantum_framework-0.20.0/quantum_framework.egg-info → quantum_framework-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.20.0
+Version: 0.22.0
 Summary: Full-stack declarative framework for building web, desktop, and mobile applications
 Author-email: Daniel Gregorio <danielgregorio2611@gmail.com>
 License: MIT
@@ -79,17 +79,21 @@ Retrieval-augmented generation, as a language construct:
     <q:source type="directory" path="./docs/" pattern="*.md" />
   </q:knowledge>
 
-  <q:query name="answer" datasource="knowledge:docs" mode="rag">
-    SELECT answer FROM chunks WHERE content SIMILAR TO :question
-    <q:param name="question" value="{form.question}" type="string" />
-  </q:query>
+  <q:llm name="answer" model="phi3" knowledge="docs" minRelevance="0.79">
+    <q:message role="user">{form.question}</q:message>
+  </q:llm>
 
-  <p>{answer.answer}</p>
+  <p>{answer}</p>
+  <q:loop type="array" items="{answer_result.sources}" var="s">
+    <p>[{s.n}] {s.name}</p>
+  </q:loop>
 </q:component>
 ```
 
 That indexes a directory, embeds it, stores the vectors, retrieves the relevant chunks
-and asks the model — in the markup. There is no Python file behind it.
+and asks the model to answer from them, citing each one — in the markup. When no
+chunk is relevant enough, the model is not asked at all. There is no Python file
+behind it.
 
 An agent with its own tools, same idea:
 

{quantum_framework-0.20.0 → quantum_framework-0.22.0}/README.md

@@ -29,17 +29,21 @@ Retrieval-augmented generation, as a language construct:
     <q:source type="directory" path="./docs/" pattern="*.md" />
   </q:knowledge>
 
-  <q:query name="answer" datasource="knowledge:docs" mode="rag">
-    SELECT answer FROM chunks WHERE content SIMILAR TO :question
-    <q:param name="question" value="{form.question}" type="string" />
-  </q:query>
-
-  <p>{answer.answer}</p>
+  <q:llm name="answer" model="phi3" knowledge="docs" minRelevance="0.79">
+    <q:message role="user">{form.question}</q:message>
+  </q:llm>
+
+  <p>{answer}</p>
+  <q:loop type="array" items="{answer_result.sources}" var="s">
+    <p>[{s.n}] {s.name}</p>
+  </q:loop>
 </q:component>
 ```
 
 That indexes a directory, embeds it, stores the vectors, retrieves the relevant chunks
-and asks the model — in the markup. There is no Python file behind it.
+and asks the model to answer from them, citing each one — in the markup. When no
+chunk is relevant enough, the model is not asked at all. There is no Python file
+behind it.
 
 An agent with its own tools, same idea:
 

{quantum_framework-0.20.0 → quantum_framework-0.22.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.20.0"
+version = "0.22.0"
 description = "Full-stack declarative framework for building web, desktop, and mobile applications"
 readme = "README.md"
 license = {text = "MIT"}
@@ -78,20 +78,26 @@ Changelog = "https://github.com/danielgregorio/quantum/releases"
 Repository = "https://github.com/danielgregorio/quantum"
 
 [tool.setuptools.packages.find]
-# So o pacote `quantum` e seus subpacotes. O glob anterior `quantum*` varria
-# junto `quantum_admin` (app FastAPI separado, com deps proprias que nao sao
-# do core), e as pastas `quantum-as4`/`quantum-lsp` (projetos irmaos,
-# hifenados e nem importaveis) — 91 arquivos de peso morto no wheel. O ponto
-# em `quantum.*` casa subpacotes; sem ele, `quantum_admin` nao entra.
+# Only the `quantum` package and its subpackages. The old glob `quantum*` also
+# swept in `quantum_admin` (a separate FastAPI app, with deps of its own that
+# are not the core's), and the `quantum-as4`/`quantum-lsp` folders (sibling
+# projects, hyphenated and not even importable) — 91 files of dead weight in
+# the wheel. The dot in `quantum.*` matches subpackages; without it,
+# `quantum_admin` does not get in.
 include = ["quantum", "quantum.*",
            # The admin (`quantum admin`, extra [admin]): its screens, its
-           # services and the backend library they use. The backend's
-           # FastAPI modules ship with it, unused by the screens.
-           "quantum_admin", "quantum_admin.services", "quantum_admin.backend"]
+           # services and the library they use (quantum_admin.core). The old
+           # FastAPI backend (quantum_admin/backend) is not shipped (A4.2).
+           "quantum_admin", "quantum_admin.services", "quantum_admin.core"]
 
 [tool.setuptools.package-data]
 quantum_admin = ["components/**/*.q", "assets/*"]
 
+[tool.setuptools.exclude-package-data]
+# Without this, setuptools ships every folder under quantum_admin as "data".
+quantum_admin = ["backend/*", "backend/**/*", "templates/**/*", "static/**/*", "projects/**/*",
+                 "settings/**/*", "*.db"]
+
 
 [tool.black]
 line-length = 100

{quantum_framework-0.20.0 → quantum_framework-0.22.0}/quantum/cli/admin.py

@@ -42,14 +42,14 @@ def create_admin_parser(subparsers):
 
 def missing_dependencies():
     """Names of the [admin] extra's packages that do not import."""
-    faltando = []
-    for modulo, pacote in (("sqlalchemy", "SQLAlchemy"), ("jwt", "PyJWT"),
+    missing = []
+    for module, package in (("sqlalchemy", "SQLAlchemy"), ("jwt", "PyJWT"),
                            ("cryptography", "cryptography")):
         try:
-            __import__(modulo)
+            __import__(module)
         except ImportError:
-            faltando.append(pacote)
-    return faltando
+            missing.append(package)
+    return missing
 
 
 def _package() -> Path:
@@ -66,42 +66,42 @@ def assets_folder() -> Path:
     return _package() / "assets"
 
 
-def _secret(arquivo: Path) -> str:
+def _secret(file: Path) -> str:
     """A key kept in the data folder, so sessions survive a restart."""
-    if arquivo.exists():
-        return arquivo.read_text(encoding="utf-8").strip()
-    chave = secrets.token_hex(32)
-    arquivo.write_text(chave, encoding="utf-8")
+    if file.exists():
+        return file.read_text(encoding="utf-8").strip()
+    key = secrets.token_hex(32)
+    file.write_text(key, encoding="utf-8")
     try:
-        arquivo.chmod(0o600)
+        file.chmod(0o600)
     except OSError:
         pass
-    return chave
+    return key
 
 
 def prepare(data: str, root: str, port: int) -> Path:
     """Create the data folder, point the admin at it, write the config. Returns its path."""
     import yaml
 
-    pasta = Path(data).resolve()
-    (pasta / "settings").mkdir(parents=True, exist_ok=True)
+    folder = Path(data).resolve()
+    (folder / "settings").mkdir(parents=True, exist_ok=True)
 
-    # Read by quantum_admin.backend at import time, so set before any import.
-    os.environ["QUANTUM_ADMIN_DATABASE_URL"] = f"sqlite:///{(pasta / 'quantum_admin.db').as_posix()}"
-    os.environ["QUANTUM_ADMIN_SETTINGS_DIR"] = str(pasta / "settings")
+    # Read by quantum_admin.core at import time, so set before any import.
+    os.environ["QUANTUM_ADMIN_DATABASE_URL"] = f"sqlite:///{(folder / 'quantum_admin.db').as_posix()}"
+    os.environ["QUANTUM_ADMIN_SETTINGS_DIR"] = str(folder / "settings")
     os.environ["QUANTUM_ADMIN_ROOT"] = str(Path(root).resolve())
-    os.environ.setdefault("JWT_SECRET_KEY", _secret(pasta / "jwt_secret"))
+    os.environ.setdefault("JWT_SECRET_KEY", _secret(folder / "jwt_secret"))
 
-    config = pasta / "quantum.config.yaml"
+    config = folder / "quantum.config.yaml"
     config.write_text(
         "# Generated by `quantum admin` on every start; edits are overwritten.\n" +
         yaml.safe_dump({
             "server": {"host": "127.0.0.1", "port": port, "reload": False, "debug": False},
             "paths": {"components": screens_folder().as_posix(),
                       "static": assets_folder().as_posix(),
-                      "uploads": (pasta / "uploads").as_posix(),
-                      "logs": (pasta / "logs").as_posix()},
-            "security": {"login_url": "/admin/login", "secret_key": _secret(pasta / "session_secret")},
+                      "uploads": (folder / "uploads").as_posix(),
+                      "logs": (folder / "logs").as_posix()},
+            "security": {"login_url": "/admin/login", "secret_key": _secret(folder / "session_secret")},
             "logging": {"level": "WARNING", "console": True, "file": False},
             "services": MODULES,
         }, sort_keys=False),
@@ -110,15 +110,15 @@ def prepare(data: str, root: str, port: int) -> Path:
 
 
 def handle_admin(args) -> int:
-    faltando = missing_dependencies()
-    if faltando:
-        print(f"[ERROR] The admin needs {', '.join(faltando)}. Install with:\n  {INSTALL_HINT}")
+    missing = missing_dependencies()
+    if missing:
+        print(f"[ERROR] The admin needs {', '.join(missing)}. Install with:\n  {INSTALL_HINT}")
         return 1
 
     config = prepare(args.data, args.root, args.port)
 
     from quantum.runtime.web_server import QuantumWebServer
-    from quantum_admin.backend.auth_service import get_auth_service
+    from quantum_admin.core.auth_service import get_auth_service
 
     # Created now, not at the first login, so a generated password is printed
     # before the URL instead of in the middle of the request log.

quantum_framework-0.22.0/quantum/cli/check.py

@@ -0,0 +1,236 @@
+"""`quantum check`: every page parses, every q:query compiles against the database,
+and every `{query.field}` a page reads is a column the query returns (M8, DEV-3).
+
+A typo in SQL or in a field name used to surface only when someone opened the
+page — `no such column` as a 500, or, for a field, an empty cell. This reads
+the project the way the server would and reports each problem with its file
+and line, without running anything: a query is compiled by the database
+(EXPLAIN) and a SELECT's columns come from running it with LIMIT 0.
+"""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional
+
+# Fields of `<name>_result` and of a query row that are not columns.
+_META = {'recordCount', 'columnList', 'executionTime', 'success', 'error', 'sql', 'page',
+         'totalPages', 'hasMore', 'cached', 'affectedRows', 'lastInsertId', 'data', 'length'}
+_EXPR = re.compile(r'\{([^{}]*)\}')
+
+
+@dataclass
+class Problem:
+    file: str
+    line: Optional[int]
+    message: str
+
+    def __str__(self) -> str:
+        return f'{self.file}:{self.line or "?"}: {self.message}'
+
+
+def _config(config_path: Path) -> dict:
+    import yaml
+    from quantum.core.config_env import expand_env
+    if not config_path.exists():
+        return {}
+    return expand_env(yaml.safe_load(config_path.read_text(encoding='utf-8')) or {})
+
+
+def _children(node) -> Iterator:
+    """The nodes inside a node, whatever the field is called."""
+    for field in ('statements', 'body', 'if_body', 'else_body', 'children', 'tools'):
+        for child in getattr(node, field, None) or []:
+            if hasattr(child, '__dict__'):
+                yield child
+    for block in getattr(node, 'elseif_blocks', None) or []:
+        body = block.get('body') if isinstance(block, dict) else getattr(block, 'body', None)
+        for child in body or []:
+            yield child
+
+
+def _texts(node) -> List[str]:
+    """The strings of a node that may hold {expressions}."""
+    texts = []
+    for field, value in vars(node).items():
+        if field.startswith('_') or field in ('sql',):
+            continue
+        if isinstance(value, str) and '{' in value:
+            texts.append(value)
+        elif isinstance(value, dict):
+            texts += [v for v in value.values() if isinstance(v, str) and '{' in v]
+    return texts
+
+
+class ProjectChecker:
+    def __init__(self, project: Path, config_path: Path):
+        self.project = project
+        self.config = _config(config_path)
+        self.datasources = self.config.get('datasources') or {}
+        self._connections: Dict[str, object] = {}
+        self.problems: List[Problem] = []
+        self.notes: List[str] = []
+        self.queries_checked = 0
+        self.files = 0
+
+    # -- the database ---------------------------------------------------------
+
+    def _connection(self, name: str):
+        from quantum.runtime.db_schema import SchemaError, connect_readonly
+        if name not in self._connections:
+            try:
+                self._connections[name] = connect_readonly(self.datasources[name], self.project)
+            except SchemaError as exc:
+                self._connections[name] = None
+                self.notes.append(f'datasource {name!r} not checked: {exc}')
+        return self._connections[name]
+
+    # -- a file ---------------------------------------------------------------
+
+    def check_file(self, path: Path) -> None:
+        from quantum.core.parser import QuantumParser
+        rel = path.relative_to(self.project).as_posix() if path.is_relative_to(self.project) else str(path)
+        self.files += 1
+        try:
+            ast = QuantumParser(use_cache=False).parse_file(str(path))
+        except Exception as exc:        # a parse error is a problem like any other
+            first_line = str(exc).split('\n')[0]
+            self.problems.append(Problem(rel, getattr(exc, 'line', None), first_line))
+            return
+        columns: Dict[str, List[str]] = {}
+        self._queries(ast, rel, columns)
+        self._fields(ast, rel, columns, {name: name for name in columns}, None)
+
+    def check_test_file(self, path: Path) -> None:
+        """A *.test.q next to the pages: it parses as a test suite (TEST-4), not as a page."""
+        from quantum.core.features.native_testing.src import TestParseError, parse_test_file
+        rel = path.relative_to(self.project).as_posix() if path.is_relative_to(self.project) else str(path)
+        self.files += 1
+        try:
+            parse_test_file(path)
+        except TestParseError as exc:
+            self.problems.append(Problem(rel, exc.line, str(exc).split('\n')[0]))
+
+    def _queries(self, node, rel: str, columns: Dict[str, List[str]]) -> None:
+        from quantum.core.ast_nodes import ActionNode, QueryNode
+        from quantum.runtime.db_schema import check_sql, read_schema
+        for child in _children(node):
+            if isinstance(child, ActionNode) and getattr(child, 'table', None):
+                # UI-10: the table the action takes its params from exists, with those columns.
+                ds = child.table_datasource
+                if ds not in self.datasources:
+                    self.problems.append(Problem(rel, getattr(child, 'source_line', None),
+                                                 f'<q:action name="{child.name}">: datasource {ds!r} is not '
+                                                 f'declared in quantum.config.yaml'))
+                elif self._connection(ds) is not None:
+                    schema = read_schema(self._connection(ds))
+                    table = schema.get(child.table)
+                    if table is None:
+                        self.problems.append(Problem(rel, getattr(child, 'source_line', None),
+                                                     f'<q:action name="{child.name}" table="{child.table}">: '
+                                                     f'no such table (tables: {", ".join(schema) or "none"})'))
+                    else:
+                        for column in child.table_columns or []:
+                            if column not in table.columns:
+                                self.problems.append(Problem(
+                                    rel, getattr(child, 'source_line', None),
+                                    f'<q:action name="{child.name}" columns=...>: table "{child.table}" '
+                                    f'has no column "{column}"'))
+            if isinstance(child, QueryNode):
+                ds = child.datasource
+                if not ds or ds.startswith('knowledge:') or getattr(child, 'source', None):
+                    pass                                 # RAG or query of queries: not SQL on a database
+                elif ds not in self.datasources:
+                    self.problems.append(Problem(rel, getattr(child, 'source_line', None),
+                                                 f'<q:query name="{child.name}">: datasource {ds!r} is not '
+                                                 f'declared in quantum.config.yaml'))
+                else:
+                    conn = self._connection(ds)
+                    if conn is not None:
+                        self.queries_checked += 1
+                        error, cols = check_sql(conn, child.sql or '')
+                        if error:
+                            self.problems.append(Problem(rel, getattr(child, 'source_line', None),
+                                                         f'<q:query name="{child.name}">: {error}'))
+                        elif cols is not None:
+                            columns[child.name] = cols
+            self._queries(child, rel, columns)
+
+    def _fields(self, node, rel: str, columns: Dict[str, List[str]], bound: Dict[str, str],
+                line: Optional[int]) -> None:
+        """Each `{var.field}` where var is a query, or a row of one, names a column it returns."""
+        from quantum.core.features.loops.src.ast_node import LoopNode
+        from quantum.core.features.ui_engine.src.ast_nodes import UIColumnNode, UIListNode, UITableNode
+        line = getattr(node, 'source_line', None) or line
+        for text in _texts(node):
+            for expr in _EXPR.findall(text):
+                for var, field in re.findall(r'(?<![\w.])(\w+)\.(\w+)', expr):
+                    self._field(rel, line, columns, bound, var, field)
+        if isinstance(node, UIColumnNode) and node.key and '$table' in bound:
+            self._field(rel, line, columns, bound, '$table', node.key, f'<ui:column key="{node.key}">')
+
+        for child in _children(node):
+            inner = dict(bound)
+            source = None
+            if isinstance(child, LoopNode):
+                source = child.query_name if child.loop_type == 'query' else _single_name(child.items)
+                if source in columns:
+                    inner[child.var_name] = source
+            elif isinstance(child, (UITableNode, UIListNode)):
+                source = _single_name(child.source)
+                if source in columns:
+                    inner[child.as_var or ('row' if isinstance(child, UITableNode) else 'item')] = source
+                    if isinstance(child, UITableNode):
+                        inner['$table'] = source
+            self._fields(child, rel, columns, inner, line)
+
+    def _field(self, rel, line, columns, bound, var, field, label=None) -> None:
+        query = bound.get(var)
+        if query is None or field in _META:
+            return
+        cols = columns.get(query, [])
+        if field not in cols:
+            shown = label or f'{{{var}.{field}}}'
+            self.problems.append(Problem(
+                rel, line, f'{shown}: query "{query}" returns no column "{field}" '
+                            f'(columns: {", ".join(cols) or "none"})'))
+
+    # -- the project ----------------------------------------------------------
+
+    def run(self) -> List[Problem]:
+        folder = self.project / (self.config.get('paths', {}) or {}).get('components', 'components')
+        if not folder.exists():
+            self.notes.append(f'no components folder at {folder}')
+            return self.problems
+        for path in sorted(folder.rglob('*.q')):
+            if path.name.endswith('.test.q'):
+                self.check_test_file(path)       # a test suite next to its page (TEST-1)
+                continue
+            self.check_file(path)
+        for conn in self._connections.values():
+            if conn is not None:
+                conn.close()
+        return self.problems
+
+
+def _single_name(expr: Optional[str]) -> Optional[str]:
+    """`{tasks}` -> 'tasks'; anything more complex -> None."""
+    m = re.fullmatch(r'\s*\{\s*(\w+)\s*\}\s*', expr or '')
+    return m.group(1) if m else None
+
+
+def run_check(config_path: str = 'quantum.config.yaml') -> int:
+    """`quantum check`: print each problem as file:line: message; exit 1 if there is any."""
+    path = Path(config_path).resolve()
+    checker = ProjectChecker(path.parent, path)
+    problems = checker.run()
+    for note in checker.notes:
+        print(f'[NOTE] {note}')
+    for problem in problems:
+        print(problem)
+    summary = (f'{checker.files} file(s), {checker.queries_checked} query(ies) checked against the database')
+    if problems:
+        print(f'\n{len(problems)} problem(s) — {summary}.')
+        return 1
+    print(f'OK — {summary}.')
+    return 0

{quantum_framework-0.20.0 → quantum_framework-0.22.0}/quantum/cli/deploy.py

@@ -43,9 +43,9 @@ class QuantumDeployer:
         '.env',
         '.env.local',
         '.env.*.local',
-        # `.env` sozinho so casava com o arquivo com esse nome exato:
-        # `.env.production` e `.env.prod` iam para o servidor junto com o
-        # resto.
+        # `.env` alone only matched the file with that exact name:
+        # `.env.production` and `.env.prod` went to the server along with the
+        # rest.
         '.env.*',
         'node_modules',
         '.venv',
@@ -67,12 +67,12 @@ class QuantumDeployer:
         self.config = self._load_config(config_path)
         self.targets = self.config.get('deploy', {}).get('targets', {})
 
-    # O que `.env.*` NAO deve levar junto.
+    # What `.env.*` must NOT take along.
     #
-    # `.env.example` e o oposto de um segredo: e a documentacao de quais
-    # variaveis o operador precisa definir, e e o arquivo que se QUER no
-    # servidor. Um `.env.*` cru arrastava esses tambem — trocar um vazamento
-    # por uma omissao silenciosa nao e conserto.
+    # `.env.example` is the opposite of a secret: it documents which
+    # variables the operator has to define, and it is the file one WANTS on
+    # the server. A bare `.env.*` dragged these along too — trading a leak
+    # for a silent omission is not a fix.
     KEEP_PATTERNS = [
         '.env.example',
         '.env.sample',
@@ -83,26 +83,26 @@ class QuantumDeployer:
 
     @classmethod
     def _is_excluded(cls, name: str) -> bool:
-        """O nome casa com algum EXCLUDE_PATTERN?
-
-        Isto era um casador escrito a mao que so entendia quatro formas:
-        `*x*`, `*.ext`, `prefixo*` e igualdade exata. Um `*` no MEIO caia no
-        ultimo caso, e tres patterns da lista tem um:
-
-            .env.*.local   ->  `.env.production.local` era EMPACOTADO E
-                               ENVIADO ao servidor. Segredo de producao no
-                               tarball, sem aviso nenhum.
-            test_*.py      ->  testes iam junto
-            *_test.py      ->  idem
-
-        Nenhum dos tres casava com nada, a nao ser com um arquivo chamado
-        literalmente `.env.*.local`. fnmatch entende as tres formas — e as
-        outras continuam funcionando igual.
-
-        `fnmatchcase`, nao `fnmatch`: o segundo normaliza a caixa conforme o
-        sistema, entao a mesma lista excluiria coisas diferentes no Windows e
-        no Linux, e um deploy feito de um lado subiria um conjunto de
-        arquivos diferente do outro.
+        """Does the name match some EXCLUDE_PATTERN?
+
+        This used to be a hand-written matcher that understood only four forms:
+        `*x*`, `*.ext`, `prefix*` and exact equality. A `*` in the MIDDLE fell
+        into the last case, and three patterns in the list have one:
+
+            .env.*.local   ->  `.env.production.local` was PACKED AND
+                               SENT to the server. A production secret in
+                               the tarball, with no warning at all.
+            test_*.py      ->  tests went along
+            *_test.py      ->  ditto
+
+        None of the three matched anything, except a file literally named
+        `.env.*.local`. fnmatch understands all three forms — and the
+        others keep working the same.
+
+        `fnmatchcase`, not `fnmatch`: the latter normalizes case according to
+        the OS, so the same list would exclude different things on Windows and
+        on Linux, and a deploy made from one side would upload a different set
+        of files than from the other.
         """
         if any(fnmatch.fnmatchcase(name, pattern)
                for pattern in cls.KEEP_PATTERNS):
@@ -273,17 +273,17 @@ class QuantumDeployer:
         os.close(fd)
         tarball_path = Path(tarball_path)
 
-        def should_exclude(item: Path, raiz: Path) -> bool:
-            """O item, ou algum diretorio dele ATE `raiz`, e excluido?
+        def should_exclude(item: Path, root: Path) -> bool:
+            """Is the item, or one of its directories UP TO `root`, excluded?
 
-            So ate a raiz. Antes era `[item] + list(item.parents)`, e
-            `parents` sobe ate a raiz do disco: um app em
-            `C:\\...\\venv\\meuapp` ou `~/projetos/tests/app` casava com um
-            pattern num diretorio de FORA do app, e o tarball saia vazio —
-            "deploy com sucesso" de nada.
+            Only up to the root. It used to be `[item] + list(item.parents)`, and
+            `parents` climbs up to the root of the disk: an app at
+            `C:\\...\\venv\\myapp` or `~/projects/tests/app` matched a
+            pattern in a directory OUTSIDE the app, and the tarball came out
+            empty — a "successful deploy" of nothing.
             """
-            return any(self._is_excluded(parte)
-                       for parte in item.relative_to(raiz).parts)
+            return any(self._is_excluded(part)
+                       for part in item.relative_to(root).parts)
 
         with tarfile.open(tarball_path, 'w:gz') as tar:
             # Add app files
@@ -314,10 +314,10 @@ class QuantumDeployer:
                     if verbose:
                         print(f"  [INFO] Including quantum runtime from {quantum_src}")
                     for item in quantum_src.rglob('*'):
-                        # Tambem pelos diretorios: antes so o NOME do arquivo
-                        # era testado, entao `tests/` do runtime era pulado
-                        # como diretorio mas todo arquivo dentro dele ia
-                        # junto.
+                        # By the directories too: only the file's NAME used
+                        # to be tested, so the runtime's `tests/` was skipped
+                        # as a directory but every file inside it went
+                        # along.
                         if should_exclude(item, quantum_src):
                             continue
                         if item.is_file():
@@ -442,17 +442,17 @@ class QuantumAppsManager:
             response.raise_for_status()
             return response.json().get('apps', [])
         except requests.exceptions.ConnectionError as e:
-            # O alvo default e `http://forge:9000`, um host que so resolve na
-            # rede de quem escreveu isto. Para todo mundo, `quantum apps`
-            # falhava com um erro de DNS citando um nome nunca visto e sem
-            # dizer de onde ele veio.
+            # The default target is `http://forge:9000`, a host that only
+            # resolves on the network of whoever wrote this. For everyone else,
+            # `quantum apps` failed with a DNS error citing a never-seen name
+            # and without saying where it came from.
             raise DeployError(
-                f"Nao consegui falar com o servidor de deploy em {url}.\n"
-                f"  Esse e o alvo '{target}'. Se voce nao tem um servidor "
-                f"Quantum Forge, este comando nao se aplica a voce.\n"
-                f"  Para apontar para outro lugar: "
-                f"QUANTUM_FORGE_URL=http://seu-host:porta\n"
-                f"  Detalhe: {e}"
+                f"Could not reach the deploy server at {url}.\n"
+                f"  That is the target '{target}'. If you do not have a "
+                f"Quantum Forge server, this command does not apply to you.\n"
+                f"  To point it somewhere else: "
+                f"QUANTUM_FORGE_URL=http://your-host:port\n"
+                f"  Detail: {e}"
             )
         except requests.exceptions.RequestException as e:
             raise DeployError(f"Failed to list apps: {e}")

{quantum_framework-0.20.0 → quantum_framework-0.22.0}/quantum/cli/hot_reload.py

@@ -412,7 +412,7 @@ class HotReloadManager:
             ws_port: WebSocket server port
             debounce_ms: Debounce delay in milliseconds
             on_reload: Optional callback when reload is triggered
-            console: Optional console for logging (from cli.utils)
+            console: Optional console for logging
         """
         self.watch_paths = watch_paths or [Path('.')]
         self.extensions = extensions or ['.q', '.yaml', '.yml', '.css', '.js', '.html']