nativegate 0.1.1__tar.gz → 0.1.3__tar.gz

{nativegate-0.1.1 → nativegate-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.1
+Version: 0.1.3
 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.1 → nativegate-0.1.3}/nativegate/cli.py

@@ -60,6 +60,7 @@ from .ir import (
     IRSchemaError,
     ModuleIR,
     NativeTypeError,
+    is_valid_python_name,
     module_from_dict,
     module_to_dict,
     validate as validate_ir,
@@ -68,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"
 
@@ -243,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.
@@ -309,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)}")
@@ -1241,6 +1292,22 @@ def clean(name: str) -> None:
 def _scaffold_service(name: str, language: str, force: bool) -> Path:
     import shutil
 
+    # Reject before anything is written: the name becomes a Python package
+    # (services/<name>/python/<name>/), so `specfun-gamma` would fail at
+    # generate time with `from ._native.specfun-gamma import ...` — invalid
+    # syntax caught by the generated-file compile() gate, three commands
+    # and a wasted scaffold after the user typed the name. Saying so here
+    # costs nothing (DEFECTS D9, found on first contact with netlib
+    # specfun, where quickstart defaults the name to the file stem and
+    # `specfun-gamma` is the obvious thing to type).
+    if not is_valid_python_name(name):
+        raise click.ClickException(
+            f"Service name '{name}' is not usable: it becomes a Python package, "
+            "so it must be a valid identifier (letters, digits, underscores, "
+            "not starting with a digit, not a Python keyword). "
+            "Use underscores instead of dashes."
+        )
+
     service_dir = Path(SERVICES_DIR) / name
     if service_dir.exists():
         if not force:
@@ -1702,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():
@@ -1893,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.1 → nativegate-0.1.3}/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.
@@ -819,6 +827,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 +862,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.3/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.1 → nativegate-0.1.3}/nativegate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.1
+Version: 0.1.3
 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.1 → nativegate-0.1.3}/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
@@ -61,6 +62,7 @@ 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
@@ -93,6 +95,7 @@ tests/test_pyproject_gen.py
 tests/test_quickstart.py
 tests/test_scalar_ref.py
 tests/test_service_gen.py
+tests/test_service_name_validation.py
 tests/test_shared_libraries.py
 tests/test_structural_invariants.py
 tests/test_suggest.py

{nativegate-0.1.1 → nativegate-0.1.3}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nativegate"
-version = "0.1.1"
+version = "0.1.3"
 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.3/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

nativegate-0.1.3/tests/test_service_name_validation.py

@@ -0,0 +1,47 @@
+"""D9 regression: dash-named services are rejected at scaffold time, not
+at generate time with invalid generated Python.
+
+First contact with netlib specfun (2026-09-23): `ngate quickstart gamma.f
+--name specfun-gamma` scaffolded cleanly, generated
+`from ._native.specfun-gamma import ...` — invalid syntax — and only
+nativegate's generated-file compile() gate refused to write it, three
+commands after the moment the user should have been told.
+"""
+
+import pytest
+from click.testing import CliRunner
+
+from nativegate import cli
+
+
+@pytest.fixture()
+def scratch(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    return tmp_path
+
+
+@pytest.mark.parametrize("bad", ["specfun-gamma", "2lib", "class"])
+def test_create_service_rejects_non_identifier_names(scratch, bad):
+    result = CliRunner().invoke(cli.main, ["create-service", bad, "--language", "fortran"])
+    assert result.exit_code != 0
+    assert "Python package" in result.output
+    # nothing may have been written
+    assert not (scratch / "services").exists()
+
+
+def test_quickstart_rejects_dash_named_service_and_explains(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    source = tmp_path / "gamma.f"
+    source.write_text("      DOUBLE PRECISION FUNCTION DGAMMA(X)\n      END\n")
+    result = CliRunner().invoke(
+        cli.main, ["quickstart", str(source), "--name", "specfun-gamma"]
+    )
+    assert result.exit_code != 0
+    assert "--name specfun_gamma" not in result.output
+
+
+def test_valid_underscored_name_still_scaffolds(scratch):
+    result = CliRunner().invoke(
+        cli.main, ["create-service", "specfun_gamma", "--language", "fortran"]
+    )
+    assert result.exit_code == 0, result.output