nativegate 0.1.2__tar.gz → 0.1.4__tar.gz

{nativegate-0.1.2 → nativegate-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.2
+Version: 0.1.4
 Summary: Make legacy C++/C/Fortran AI-ready and microservice-ready: expose native code as an MCP server, REST API and container
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{nativegate-0.1.2 → nativegate-0.1.4}/nativegate/cli.py

@@ -69,6 +69,7 @@ from .parsers import cpp as cpp_parser
 from .parsers.cpp_ast import ClangOptions
 from .parsers import fixed_form
 from .parsers import fortran as fortran_parser
+from .parsers.dialect import apply_dialect, is_dialect_marked, resolve_dialect
 
 SERVICES_DIR = "services"
 
@@ -244,7 +245,15 @@ def create_service(name: str, language: str, force: bool) -> None:
     help="Delete and recreate services/<name> if it already exists.",
 )
 @click.option("--build/--no-build", default=False, help="Also compile the extension after generating.")
-def quickstart(source: Path, name: str | None, force: bool, build: bool) -> None:
+@click.option(
+    "--dialect",
+    default="",
+    help="Select the live half of netlib-style dual-dialect sources "
+    "(CS/CD machine-precision marking): 'cs' or 'cd'. The resolved copy "
+    "goes to native/_expanded; the source under native/ is untouched. "
+    "Leave empty for sources that are not dialect-marked.",
+)
+def quickstart(source: Path, name: str | None, force: bool, build: bool, dialect: str) -> None:
     """One-shot: scaffold a service from a single C++/Fortran file, expose
     everything found in it, and generate the Python package — no manual
     nativegate.yaml editing.
@@ -310,10 +319,51 @@ def quickstart(source: Path, name: str | None, force: bool, build: bool) -> None
                         f"{service_dir / 'native'} and re-run `ngate generate {service_name}`."
                     )
         else:
-            routines = fortran_parser.list_routine_names(native_copy)
+            resolved = native_copy
+            try:
+                config.dialect = resolve_dialect(dialect)
+            except ValueError as exc:
+                tracker.fail("Copy native source")
+                raise click.ClickException(str(exc)) from exc
+            if config.dialect and is_dialect_marked(read_source(native_copy)):
+                resolved_dir = service_dir / "native" / "_expanded"
+                resolved_dir.mkdir(parents=True, exist_ok=True)
+                resolved = resolved_dir / native_copy.name
+                resolved.write_text(apply_dialect(read_source(native_copy), config.dialect))
+                tracker.log(
+                    f"dialect '{config.dialect}' selected for {native_copy.name} "
+                    f"-> {resolved} (native/ keeps the untouched upstream bytes)"
+                )
+            else:
+                config.dialect = ""
+            try:
+                routines = fortran_parser.list_routine_names(resolved)
+            except ValueError as exc:
+                # Why not pass the parser's message through untouched: for a
+                # netlib CS/CD dual-dialect deck the parser error ("floating
+                # continuation") is real but does not name the fix, which is
+                # one flag on this very command.
+                hint = ""
+                if not config.dialect and is_dialect_marked(read_source(native_copy)):
+                    hint = (
+                        "\nThis file looks dialect-marked (CS/CD prefix on both "
+                        "a single- and a double-precision copy of every line). "
+                        "Pass '--dialect cs' or '--dialect cd' to select the "
+                        "live half."
+                    )
+                tracker.fail("Copy native source")
+                raise click.ClickException(f"{exc}{hint}") from exc
             if not routines:
                 tracker.fail("Copy native source")
-                raise click.ClickException(f"No Fortran function/subroutine declarations found in {source}.")
+                hint = ""
+                if not config.dialect and is_dialect_marked(read_source(native_copy)):
+                    hint = (
+                        " (The source carries netlib CS/CD dual-dialect marking: "
+                        "pass --dialect cs or --dialect cd to select the live half.)"
+                    )
+                raise click.ClickException(
+                    f"No Fortran function/subroutine declarations found in {source}.{hint}"
+                )
             config.expose.functions = routines
             config.save(service_dir)
             tracker.log(f"Exposing Fortran routines: {', '.join(routines)}")
@@ -1719,6 +1769,35 @@ def _generate_fortran_service(service_dir: Path, config: ServiceConfig) -> None:
     if not sources:
         raise click.ClickException(f"No Fortran sources found under {service_dir / 'native'}.")
 
+    # netlib dual-dialect sources (CS/CD stamped on both halves' every line)
+    # are not parseable by anything that reads real Fortran — see
+    # DEFECTS D10. The selected dialect's lines become the code, the other
+    # becomes a comment, and the resolved copy lives in `_expanded` next
+    # to the other generated transforms. Done at the very front, so every
+    # reader of a source (routine discovery, the parse, intent inference,
+    # f2py) sees the same resolved file.
+    dialect_set = set()
+    if config.dialect:
+        chosen = [s for s in sources if is_dialect_marked(s.read_text())]
+        expanded_dir = service_dir / "native" / "_expanded"
+        expanded_dir.mkdir(parents=True, exist_ok=True)
+        replaced: list[Path] = []
+        for source in sources:
+            if source not in chosen:
+                replaced.append(source)
+                continue
+            target = expanded_dir / source.name
+            target.write_text(apply_dialect(read_source(source), config.dialect))
+            replaced.append(target)
+            dialect_set.add(target)
+        sources = replaced
+        if chosen:
+            click.echo(
+                f"Resolved dialect '{config.dialect}' in {len(chosen)} source(s) "
+                f"-> native/_expanded. The '{config.dialect}' half is now live; "
+                "the other half is commented. Originals under native/ are untouched."
+            )
+
     include_paths = [Path(p) for p in config.include_paths]
     for p in include_paths:
         if not p.is_dir():
@@ -1910,13 +1989,16 @@ def _generate_fortran_service(service_dir: Path, config: ServiceConfig) -> None:
         + kind_param_sources
         + shim_only_sources
     )
+    # Dialect-resolved copies live under _expanded by construction, so the
+    # referenced tree must be built even when nothing else needs rewriting.
+    rewritten_or_copied = bool(rewritten) or bool(library_sources) or bool(preprocessed_set) or bool(dialect_set)
     # A library source is always copied under the service, even when it needs
     # no rewriting: it lives outside native/, so referencing it as
     # `native/<name>` would name a file that is not there — and the Docker
     # build context is the service directory, so a path outside it could not be
     # COPYed in anyway.
     library_set = set(library_sources)
-    if rewritten or library_sources or preprocessed_set:
+    if rewritten_or_copied:
         expanded_dir = service_dir / "native" / "_expanded"
         expanded_dir.mkdir(parents=True, exist_ok=True)
         native_sources = []

{nativegate-0.1.2 → nativegate-0.1.4}/nativegate/config.py

@@ -10,6 +10,8 @@ from typing import TYPE_CHECKING, Union
 
 import yaml
 
+from .parsers.dialect import resolve_dialect
+
 if TYPE_CHECKING:
     from .ir import ModuleIR
 
@@ -783,6 +785,12 @@ class ServiceConfig:
     # the `_expanded` copy. Same reason clang.defines exists for C++: the
     # branches differ, and only the build knows which one is live.
     fortran_defines: list[str] = field(default_factory=list)
+    # Dialect selection for netlib-style dual-dialect sources ("cs" or
+    # "cd"), applied when a file is parsed AND before f2py compiles it.
+    # Empty means no source carries the marking; discriminating per-file
+    # is done by `is_dialect_marked`, so one value safely covers a mixed
+    # tree.
+    dialect: str = ""
     # `state:`/`invariants:`/`ranges:` — layer 3 declarations
     # (design-verification-layers.md §3.2-3.5). Optional: a service with no
     # invariants.json coverage simply has an empty VerificationConfig.
@@ -797,6 +805,26 @@ class ServiceConfig:
                 "Run `ngate create-service` first."
             )
         data = yaml.safe_load(config_path.read_text()) or {}
+        # Unknown top-level keys are an error, not dead weight. A new
+        # nativegate.yaml key read by an older nativegate (the exact case
+        # this project shipped CI against: `dialect: cd` under a nativegate
+        # that pre-dated it) would otherwise vanish the same way a letter
+        # transposed in `dialete:` would — the service generates from an
+        # assumption the user never wrote.
+        known_keys = {
+            "name", "language", "expose", "parser", "clang", "libraries",
+            "include_paths", "api", "dialect",
+            "fortran",  # namespace for fortran.defines
+            # verification layer 3 keys
+            "state", "invariants", "ranges", "lattice",
+        }
+        unknown = sorted(set(data) - known_keys)
+        if unknown:
+            raise ConfigError(
+                f"{config_path}: unknown key(s) {', '.join(unknown)}. "
+                "Check the spelling against this nativegate version's supported "
+                "keys, or upgrade nativegate if the key is new."
+            )
         expose = _load_expose(data.get("expose"), config_path)
         clang_data = data.get("clang") or {}
         # `None` means "no restriction": `expose: all` or an empty `expose:`
@@ -819,6 +847,7 @@ class ServiceConfig:
             ),
             libraries=list(data.get("libraries") or []),
             include_paths=list(data.get("include_paths") or []),
+            dialect=resolve_dialect(data.get("dialect")),
             api=_load_api(data.get("api"), config_path),
             fortran_defines=list((data.get("fortran") or {}).get("defines") or []),
             verification=_load_verification(data, config_path, known_functions),
@@ -853,6 +882,8 @@ class ServiceConfig:
             data["libraries"] = self.libraries
         if self.include_paths:
             data["include_paths"] = self.include_paths
+        if self.dialect:
+            data["dialect"] = self.dialect
         # Only written when it differs from the default, so an existing
         # nativegate.yaml does not grow a key that says nothing.
         if self.api.auth != "none":

nativegate-0.1.4/nativegate/parsers/dialect.py

@@ -0,0 +1,98 @@
+"""Dialect selection for netlib-style dual-dialect Fortran (DEFECTS D10).
+
+Some netlib-era sources (specfun 2.5 is the canonical case, 1996) mark
+machine precision by commenting EVERY statement in both dialects and
+asking the installer to comment one batch out manually:
+
+    CS    REAL FUNCTION GAMMA(X)
+    CD    DOUBLE PRECISION FUNCTION DGAMMA(X)
+    CS    REAL
+    CD    DOUBLE PRECISION
+         1    C,CONV,EPS, ...            <- no statement starts in column 7
+
+With neither prefix commented, no standard parser can read the file: the
+grammar has a floating continuation with no statement behind it, and
+gfortran rejects it too ("no implicit type at 'CS'..." paired with the
+dangling continuation). The `NATIVEGATE_FORTRAN_PARSER=regex` fallback
+does not help — the FUNCTION statements are marked the same way.
+
+`apply_dialect` makes the choice static in place: the selected prefix is
+uncommented (its two characters become blank columns) and the other
+prefix is pushed under a comment (`C` + whatever remained). Column
+positions are preserved, which is what fixed-form requires: `CS   1 `
+(col 3-6 blank, 1 in column 6) and `CD` lines follow the same geometry.
+
+Idempotent: after one pass no line starts CS/CD any more, so re-running
+on an already-resolved file is a no-op, which is what makes it safe for
+generate to apply it to every source without knowing which ones are
+marked.
+
+The transform is deliberately pure text on the fixed-form column grid:
+uncommenting replaces the two marker characters with two blanks, so no
+column ever shifts, and commenting restores the `C` in column 1. Only
+`native/_expanded/` carries the resolved file — the byte-for-byte copy
+under `native/native/...` is untouched, so provenance (`golden.json`
+hashes) keeps describing the upstream source, not the transform output.
+"""
+
+from __future__ import annotations
+
+import re
+
+DIALECT_CHOICES = ("cs", "cd")
+
+_PREFIX_RE = re.compile(r"^(CS|CD)(?=[ \t])", re.IGNORECASE | re.MULTILINE)
+
+
+def resolve_dialect(raw: str | None) -> str:
+    """Validate a `dialect:` value from nativegate.yaml / --dialect.
+
+    `""` means "the source is not dialect-marked, leave everything alone".
+    Anything unlisted is an error, not a silent no-op — a typo'd
+    `dialect: dc` must fail here, not turn into "unresolved source".
+    """
+    value = (raw or "").strip().lower()
+    if value and value not in DIALECT_CHOICES:
+        raise ValueError(
+            f"Unknown dialect '{value}'; expected one of: "
+            + ", ".join(DIALECT_CHOICES) + " (or empty for none)."
+        )
+    return value.lower()
+
+
+def is_dialect_marked(text: str) -> bool:
+    """True when any expected prefix appears at a statement column.
+
+    Deliberately coarse: a file with the markers gets resolved from the
+    start, whether or not every line carries them. A single CS/CD word
+    that opens a line is a genuine dialect marker in practice — no Fortran
+    statement begins with those letters in column 1.
+    """
+    return bool(_PREFIX_RE.search(text))
+
+
+def apply_dialect(text: str, dialect: str) -> str:
+    """Resolve the dual-dialect marking to a single live dialect.
+
+    `dialect` is the prefix that becomes the code; the other becomes a
+    comment (`C ` + the remainder), so the rejected variant stays readable
+    in place — the same shape the files will have after a human editor
+    does the step netlib's readme prescribes.
+    """
+    dialect = resolve_dialect(dialect)
+    if not dialect or not is_dialect_marked(text):
+        return text
+
+    selected = dialect.upper()
+    out = []
+    for line in text.splitlines(keepends=True):
+        match = _PREFIX_RE.match(line)
+        if not match:
+            out.append(line)
+            continue
+        marker = match.group(1).upper()
+        if marker == selected:
+            out.append("  " + line[2:])
+        else:
+            out.append("C " + line[2:])
+    return "".join(out)

{nativegate-0.1.2 → nativegate-0.1.4}/nativegate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.2
+Version: 0.1.4
 Summary: Make legacy C++/C/Fortran AI-ready and microservice-ready: expose native code as an MCP server, REST API and container
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{nativegate-0.1.2 → nativegate-0.1.4}/nativegate.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ nativegate/parsers/__init__.py
 nativegate/parsers/cpp.py
 nativegate/parsers/cpp_ast.py
 nativegate/parsers/cpp_regex.py
+nativegate/parsers/dialect.py
 nativegate/parsers/fixed_form.py
 nativegate/parsers/fortran.py
 nativegate/parsers/fortran_fparser.py
@@ -56,11 +57,13 @@ tests/test_cli_serve_verify.py
 tests/test_cli_suggest.py
 tests/test_cli_verify_aggregate.py
 tests/test_cmake_gen.py
+tests/test_config_unknown_keys.py
 tests/test_cpp_ast.py
 tests/test_cpp_driver.py
 tests/test_cpp_pipeline.py
 tests/test_declared_invariants.py
 tests/test_derived_types.py
+tests/test_dialect.py
 tests/test_docker_gen.py
 tests/test_driverbuild.py
 tests/test_endpoint_docstrings.py

{nativegate-0.1.2 → nativegate-0.1.4}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nativegate"
-version = "0.1.2"
+version = "0.1.4"
 description = "Make legacy C++/C/Fortran AI-ready and microservice-ready: expose native code as an MCP server, REST API and container"
 readme = "README.md"
 requires-python = ">=3.10"

nativegate-0.1.4/tests/test_config_unknown_keys.py

@@ -0,0 +1,77 @@
+"""Unknown top-level keys in nativegate.yaml must fail loading.
+
+Found in the wild (2026-09-23): specfun-py's CI installed a nativegate
+that pre-dated the `dialect:` key and generated the service anyway from
+an assumption never written down — the unknown key was swallowed as dead
+weight. A typo in any key was equally silent. Now both are config errors
+that say what is wrong and what to do about it.
+"""
+
+import shutil
+import textwrap
+
+import pytest
+
+from nativegate.config import ConfigError, ServiceConfig
+
+
+@pytest.fixture()
+def scratch(tmp_path, monkeypatch):
+    service = tmp_path / "demo"
+    (service / "native").mkdir(parents=True)
+    monkeypatch.chdir(tmp_path)
+    return service
+
+
+def _config_for_lines(text):
+    def _load(service):
+        (service / "nativegate.yaml").write_text(text)
+        return ServiceConfig.load(service)
+    return _load
+
+
+def test_unknown_key_is_an_error(scratch):
+    (scratch / "nativegate.yaml").write_text(textwrap.dedent("""\
+        name: demo
+        language: fortran
+        diatect: cd
+        expose:
+          functions: []
+        """))
+    with pytest.raises(ConfigError) as exc:
+        ServiceConfig.load(scratch)
+    assert "diatect" in str(exc.value)
+    assert "upgrade nativegate" in str(exc.value)
+
+
+def test_future_key_is_a_config_error_not_a_silent_noop(scratch):
+    (scratch / "nativegate.yaml").write_text(textwrap.dedent("""\
+        name: demo
+        language: fortran
+        dialect: cd
+        expose:
+          functions: []
+        """))
+    # fine on a nativegate that knows the key
+    config = ServiceConfig.load(scratch)
+    assert config.dialect == "cd"
+
+
+def test_all_declared_keys_still_load(scratch):
+    (scratch / "nativegate.yaml").write_text(textwrap.dedent("""\
+        name: demo
+        language: fortran
+        dialect: cd
+        parser: auto
+        libraries:
+        - petro
+        include_paths: []
+        fortran:
+          defines: []
+        expose:
+          all: true
+        """))
+    config = ServiceConfig.load(scratch)
+    assert config.dialect == "cd"
+    assert config.libraries == ["petro"]
+    assert config.expose.all is True

nativegate-0.1.4/tests/test_dialect.py

@@ -0,0 +1,184 @@
+"""D10: the netlib CS/CD dual-dialect marking.
+
+Sources fetched straight from netlib specfun carry every statement twice,
+in both dialects, comment-marked by prefix (CS = single, CD = double), and
+the installer comments one batch out by hand. Neither parser could read
+such a file — the fixed-form grammar sees a continuation with no statement,
+and the regex fallback finds no routine because the FUNCTION lines are
+marked too. The fix is `dialect:` in nativegate.yaml / `--dialect` on
+quickstart: the chosen prefix's lines become the code, the other prefix's
+lines become comments, and the resolved copy lives under native/_expanded
+so the untouched upstream bytes stay in native/.
+"""
+
+import textwrap
+
+import pytest
+from click.testing import CliRunner
+
+from nativegate import cli
+from nativegate.parsers.dialect import (
+    apply_dialect,
+    is_dialect_marked,
+    resolve_dialect,
+)
+
+
+# --- unit ----------------------------------------------------------------
+
+
+def test_resolve_dialect_validates():
+    assert resolve_dialect("") == ""
+    assert resolve_dialect("CS") == "cs"
+    assert resolve_dialect("cd") == "cd"
+    with pytest.raises(ValueError):
+        resolve_dialect("dc")     # plausible typo must fail, not act as a no-op
+    with pytest.raises(ValueError):
+        resolve_dialect("both")
+
+
+DUAL_DIALECT = textwrap.dedent("""\
+CS    REAL FUNCTION GAMMA(X)
+CD    DOUBLE PRECISION FUNCTION DGAMMA(X)
+CS    REAL
+CD    DOUBLE PRECISION
+     1    C,CONV,EPS
+      DGAMMA = 24.0D0
+      RETURN
+      END
+""")
+
+
+def test_apply_dialect_selects_cd():
+    out = apply_dialect(DUAL_DIALECT, "cd")
+    lines = out.splitlines()
+    # the chosen CD lines are live, shifted two columns into statement
+    # position, with no other column moved
+    assert "      DOUBLE PRECISION FUNCTION DGAMMA(X)" in lines
+    assert "      DOUBLE PRECISION" in lines
+    # the rejected CS half is commented back to the normal fixed-form
+    # comment form, `C` in column 1
+    assert "C     REAL FUNCTION GAMMA(X)" in lines
+    assert "C     REAL" in lines
+    # untouched lines are untouched
+    assert "      DGAMMA = 24.0D0" in lines
+    assert "     1    C,CONV,EPS" in lines
+
+
+def test_apply_dialect_selects_cs():
+    out = apply_dialect(DUAL_DIALECT, "cs")
+    lines = out.splitlines()
+    assert "      REAL FUNCTION GAMMA(X)" in lines
+    assert "      REAL" in lines
+    commented = [line for line in lines if line.startswith("C ")]
+    assert any("DGAMMA" in line and "DOUBLE PRECISION FUNCTION" in line
+               for line in commented)
+
+
+def test_apply_dialect_leaves_plain_source_alone():
+    plain = "      DOUBLE PRECISION FUNCTION DGAMMA(X)\n      END\n"
+    assert apply_dialect(plain, "cd") == plain
+    assert apply_dialect(plain, "") == plain
+
+
+def test_apply_dialect_is_idempotent():
+    once = apply_dialect(DUAL_DIALECT, "cd")
+    assert apply_dialect(once, "cd") == once
+    assert not is_dialect_marked(once)
+
+
+def test_is_dialect_marked():
+    assert is_dialect_marked(DUAL_DIALECT)
+    assert not is_dialect_marked(apply_dialect(DUAL_DIALECT, "cd"))
+    assert not is_dialect_marked("")
+
+
+def test_apply_dialect_rejects_bad_dialect():
+    with pytest.raises(ValueError):
+        apply_dialect(DUAL_DIALECT, "dc")
+
+
+# --- config round-trip -----------------------------------------------------
+
+
+def test_config_round_trips_dialect(tmp_path):
+    """`dialect:` survives a save/load cycle, and an unknown value is a
+    config error rather than a silently ignored key."""
+    import yaml
+    from nativegate.config import ServiceConfig
+
+    service = tmp_path / "specfun_gamma"
+    service.mkdir(parents=True)
+    (service / "nativegate.yaml").write_text(
+        yaml.dump({"name": "specfun_gamma", "language": "fortran",
+                   "dialect": "cd", "expose": {"functions": []}},
+                  sort_keys=False),
+    )
+    config = ServiceConfig.load(service)
+    assert config.dialect == "cd"
+
+    config.save(service)
+    reloaded = ServiceConfig.load(service)
+    assert reloaded.dialect == "cd"
+
+    (service / "nativegate.yaml").write_text(
+        yaml.dump({"name": "specfun_gamma", "language": "fortran",
+                   "dialect": "dc", "expose": {}},
+                  sort_keys=False),
+    )
+    with pytest.raises(Exception, match="dialect"):
+        ServiceConfig.load(service)
+
+
+# --- CLI wiring -----------------------------------------------------------
+
+
+@pytest.fixture()
+def netlib_scratch(tmp_path, monkeypatch):
+    source = tmp_path / "gamma.f"
+    source.write_text(DUAL_DIALECT)
+    monkeypatch.chdir(tmp_path)
+    return source
+
+
+def test_quickstart_dialect_generates_and_keeps_native_untouched(netlib_scratch, tmp_path):
+    result = CliRunner().invoke(
+        cli.main,
+        ["quickstart", str(netlib_scratch), "--name", "specfun_gamma",
+         "--dialect", "cd"],
+    )
+    assert result.exit_code == 0, result.output
+
+    service = tmp_path / "services" / "specfun_gamma"
+    native = service / "native" / "gamma.f"
+    assert native.read_text() == DUAL_DIALECT
+    resolved = service / "native" / "_expanded" / "gamma.f"
+    assert resolved.exists()
+    assert resolved.read_text().rstrip("\n") == apply_dialect(
+        DUAL_DIALECT, "cd"
+    ).rstrip("\n")
+
+    assert "dialect: cd" in (service / "nativegate.yaml").read_text()
+
+    init = service / "python" / "specfun_gamma" / "__init__.py"
+    assert "dgamma" in init.read_text().lower()
+
+
+def test_without_dialect_the_marked_file_fails_with_a_direction(netlib_scratch):
+    result = CliRunner().invoke(
+        cli.main, ["quickstart", str(netlib_scratch), "--name", "specfun_gamma"]
+    )
+    assert result.exit_code != 0
+    # the parser error is passed through, but the remedy is named
+    assert "dialect-marked" in result.output
+    assert "--dialect cs" in result.output and "--dialect cd" in result.output
+
+
+def test_bad_dialect_is_an_error_not_a_noop(netlib_scratch):
+    result = CliRunner().invoke(
+        cli.main,
+        ["quickstart", str(netlib_scratch), "--name", "specfun_gamma",
+         "--dialect", "dc"],
+    )
+    assert result.exit_code != 0
+    assert "Unknown dialect" in result.output