rocket-engine 0.0.2b1__py3-none-any.whl

rocket_engine/__init__.py

@@ -0,0 +1,8 @@
+"""RocketEDA shared tooling engine.
+
+No logic lives here yet. This package only declares the module boundaries
+so the locked environment and the bundled build can be proven before any
+engine behavior lands. See README.md for the module map and coding rules.
+"""
+
+__version__ = "0.0.1"

rocket_engine/__main__.py

@@ -0,0 +1,12 @@
+"""`python -m rocket_engine`: the `rocket-engine` command surface.
+
+Thin entry over the CLI inbound adapter (`adapters.cli`); a
+`[project.scripts]` binary alias can point here once packaging
+wires it. Exits: 0 execution-ok (even FAIL verdicts), 1 engine
+error, 2 usage error.
+"""
+
+from .adapters.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rocket_engine/adapters/README.md

@@ -0,0 +1,54 @@
+# adapters — transport edges and solver integrations
+
+This package contains the client transports and wrappers around existing EDA tools. composition.Engine selects a registered solver for each operation. Adapters return normalized results; project state and verdict rules stay in engine services.
+
+## Client transports
+
+| Adapter | Current surface |
+|---|---|
+| cli/ | Interactive command loop, one-operation mode, sequential --batch, and JSON output; entry point is python -m rocket_engine. |
+| mcp/ | Project-scoped MCP stdio server with one tool per catalog operation/query; descriptions come from handler docstrings. Most input schemas remain generic. |
+| http/ | HttpTransport.handle routes one JSON command/query envelope; serve_http adds a FastAPI/uvicorn POST listener on loopback only (no auth, ADR-006). SSE is not implemented here. |
+| ipc/ | IpcTransport.handle routes one JSON command/query envelope. Length-prefix framing and Electron child-process lifecycle are not implemented here. |
+
+Events are read through the engine event-query surface; HTTP SSE and pushed IPC events are not currently provided by these transport classes.
+
+## Registered solver adapters
+
+| Operation | Registered tool(s) |
+|---|---|
+| run_drc | Magic (default), KLayout |
+| run_hdl_test, run_syntax, run_formal, run_synth, run_timing | Icarus, Slang, SBY, Yosys, OpenSTA |
+| run_spice, run_post_layout, run_cosim | ngspice; run_cosim also uses Icarus |
+| run_optical, run_em | SAX/Circulax, MEOW |
+| run_extraction, run_lvs | Magic, Netgen |
+| run_connectivity, run_erc, run_view_sync | connectgraph |
+| generate_views | GDSFactory |
+| run_digital_flow | LibreLane |
+
+The exact registration order and default tool are in [composition.py](../composition.py). A registered adapter can still be blocked by a missing executable, incompatible PDK/deck, or an unqualified flow. Use get_capabilities for machine-specific readiness; see the [DIGITAL-FLOW report](../../docs/work/DIGITAL-FLOW/report.md) for the current live-flow limitation.
+
+## Gateway rule: api contract + port adapter
+
+`api.py` is the one inbound port: it builds the single submit
+envelope (project_id, operation, arguments, minted-or-caller
+request_id) and calls the engine. Every gateway is that contract
+plus one framing adapter, composed — never inherited:
+
+- http/mcp/ipc `handle`: parse the wire frame, enforce scope, call
+  `api.submit`, serialize the result or error envelope.
+- cli/console `OpDispatcher.execute`: parse op-call text, stamp the
+  head revision on operations, call `api.submit`.
+
+Gateways own only I/O framing and wire-appropriate errors
+(UsageError on text wires, AdapterError on framed wires); the
+envelope shape, error payloads (`errors.error_payload`), and status
+mapping (`errors.status_for_code`) exist exactly once and are
+shared. A new transport adds one framing module over `api.submit`
+— never a second envelope builder, never a transport subclass.
+
+## Boundaries
+
+Transport adapters validate the envelope and project scope, then call the api contract (`api.submit` → Engine.submit). Solver adapters implement the ToolAdapter port and own tool invocation and output parsing. The intended module boundary forbids solver adapters from importing one another. Current exception: CosimAdapter calls HdlSimAdapter directly for its digital half; treat this as existing boundary debt, not a pattern to extend.
+
+For endpoint documentation rules, see [AGENTS.md](../../AGENTS.md). For operation names, see [interfaces](../interfaces/README.md) and the [generated API reference](../../docs/engine-api.md).

rocket_engine/adapters/__init__.py

@@ -0,0 +1,7 @@
+"""One duplex adapter per channel: transports and solver wrappers.
+Maps at the edge; holds no rules, state, or verdicts."""
+
+from ..interfaces import ToolAdapter
+from .errors import AdapterError
+
+__all__ = ["AdapterError", "ToolAdapter"]

rocket_engine/adapters/api.py

@@ -0,0 +1,39 @@
+"""API contract: the one inbound port every gateway calls.
+
+Gateways (http, mcp, ipc, cli/dispatcher, console) own only I/O
+framing — parsing their wire format and serializing results. They
+never build submit envelopes themselves and never subclass each
+other: every gateway composes over `submit` here (composition over
+inheritance), so the envelope shape, request-id minting, and error
+propagation exist exactly once.
+
+Validation stays at the boundaries: gateways reject unknown names
+with their wire-appropriate error (UsageError on text wires,
+AdapterError on framed wires), and Engine.submit backstops with
+unsupported_operation. Engine errors propagate untouched — mapping
+them to wire envelopes is framing, owned by each gateway with the
+shared shapes from `adapters.errors`.
+"""
+
+import uuid
+
+
+def submit(engine, project_id, operation, arguments, request_id=None):
+    """Submit one call through the engine port.
+
+    Args:
+        engine: Engine (or stand-in) exposing `submit`.
+        project_id: Project the call runs against.
+        operation: Cataloged operation or query name.
+        arguments: Operation arguments mapping.
+        request_id: Envelope id; minted when omitted.
+
+    Returns:
+        Engine result for the call (ack, completion, or data).
+    """
+    return engine.submit({
+        "project_id": project_id,
+        "operation": operation,
+        "arguments": dict(arguments),
+        "request_id": request_id or uuid.uuid4().hex,
+    })

rocket_engine/adapters/base.py

@@ -0,0 +1,46 @@
+"""Shared transport helpers: JSON parsing and project-scope enforcement."""
+
+import json
+
+from .errors import AdapterError
+
+
+def parse_json(text):
+    """Parse one JSON object request; reject anything else loudly.
+
+    Args:
+        text: Raw request text, expected to be one JSON object.
+
+    Returns:
+        Parsed request mapping.
+
+    Raises:
+        AdapterError: invalid_command when the text is not JSON or
+            not an object.
+    """
+    try:
+        data = json.loads(text)
+    except Exception as exc:
+        raise AdapterError("invalid_command", f"Cannot parse request: {exc}") from exc
+    if not isinstance(data, dict):
+        raise AdapterError("invalid_command", "Request must be a JSON object.")
+    return data
+
+
+def enforce_scope(envelope_project, bound_project):
+    """Deny envelopes outside the bound project; allow unbound use.
+
+    Args:
+        envelope_project: Project id carried by the envelope.
+        bound_project: Project this transport is bound to, or None
+            for unbound (any envelope passes).
+
+    Raises:
+        AdapterError: cross_project_denied for an envelope outside
+            the bound scope — denied, never routed.
+    """
+    if bound_project is not None and envelope_project != bound_project:
+        raise AdapterError(
+            "cross_project_denied",
+            f"Bound to {bound_project}, got {envelope_project}.",
+        )

rocket_engine/adapters/cace/__init__.py

@@ -0,0 +1,163 @@
+"""CACE characterization adapter: run_characterize port."""
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from ...execution.errors import ExecutionError
+from ...interfaces import ToolAdapter
+from ..errors import AdapterError
+
+OPERATION = "run_characterize"
+_TOOL = "cace"
+_TIMEOUT_S = 900
+_STATUS_RE = re.compile(r"\|\s*(Pass|Fail|Error|Unknown|Skip|Cancel)\s",
+                        re.IGNORECASE)
+
+
+class CaceAdapter(ToolAdapter):
+    """run_characterize via cace: CLI run plus summary.md verdicts.
+
+    Serves the run_characterize operation with tool `cace`. Runs
+    `cace <datasheet>` as a subprocess and gates on the exit code
+    (0 pass, 2 spec miss, 1/3/4 error/unknown/canceled); values
+    come from summary.md rows plus simulation_summary.csv, never
+    flow.log scraping. In-process reads reuse pure helpers only.
+
+    Job keys:
+        datasheet (required): Input datasheet YAML path.
+        run_path: Run dir parent (RUNDIR lands beneath it).
+        workdir: Run directory (default ".").
+        timeout_s: Budget in seconds (default 900).
+
+    Args:
+        runner: Optional isolated runner; direct subprocess when None.
+    """
+
+    def __init__(self, runner=None):
+        self._runner = runner
+
+    def capabilities(self, target):
+        """Report the served operation and tool.
+
+        Args:
+            target: Target the capabilities are reported for.
+
+        Returns:
+            Capability mapping with operations and tool.
+        """
+        return {"operations": [OPERATION], "tool": _TOOL}
+
+    def preflight(self, job):
+        """Check operation, datasheet, and cace presence.
+
+        Args:
+            job: Solver job with operation run_characterize.
+
+        Returns:
+            Checked mapping with datasheet, binary, timeout.
+
+        Raises:
+            AdapterError: unsupported_operation, invalid_reference
+                for a missing datasheet, missing_dependency with
+                BLOCKED-needs-host when cace is absent (2.13.0 pin).
+        """
+        if job.get("operation") != OPERATION:
+            raise AdapterError(
+                "unsupported_operation",
+                f"Cace handles {OPERATION}, got {job.get('operation')}.")
+        datasheet = job.get("datasheet")
+        if not datasheet or not Path(datasheet).is_file():
+            raise AdapterError(
+                "invalid_reference", f"Datasheet not found: {datasheet}.")
+        binary = shutil.which(_TOOL)
+        if binary is None:
+            raise AdapterError(
+                "missing_dependency",
+                "BLOCKED-needs-host: cace absent (need cace==2.13.0).")
+        try:
+            __import__("cace")
+        except ImportError as exc:
+            raise AdapterError(
+                "missing_dependency",
+                "BLOCKED-needs-host: cace python package absent.",
+            ) from exc
+        timeout = job.get("timeout_s", _TIMEOUT_S)
+        if (not isinstance(timeout, (int, float))
+                or isinstance(timeout, bool) or not timeout > 0):
+            raise AdapterError("invalid_command", f"Bad timeout: {timeout!r}.")
+        checked = {"datasheet": str(datasheet), "binary": binary,
+                   "timeout_s": timeout,
+                   "run_path": job.get("run_path")}
+        if self._runner is not None:
+            try:
+                self._runner.preflight()
+            except ExecutionError as exc:
+                raise AdapterError(exc.code, str(exc)) from exc
+        return checked
+
+    def execute(self, job):
+        """Run cace on the datasheet under a timeout.
+
+        Args:
+            job: Solver job with operation run_characterize.
+
+        Returns:
+            Native output with exit_code, stdout/stderr, summary
+                markdown, and run dir.
+        """
+        checked = self.preflight(job)
+        workdir = job.get("workdir", ".")
+        if not Path(workdir).is_dir():
+            raise AdapterError(
+                "invalid_reference", f"Workdir not found: {workdir}.")
+        argv = [checked["binary"], checked["datasheet"],
+                "--no-progress-bar"]
+        if checked["run_path"]:
+            argv.extend(["--run-path", str(checked["run_path"])])
+        try:
+            proc = subprocess.run(argv, capture_output=True, text=True,
+                                  timeout=checked["timeout_s"], cwd=workdir)
+        except subprocess.TimeoutExpired as exc:
+            raise AdapterError(
+                "runner_unavailable", "Cace run timed out.") from exc
+        summary = ""
+        run_dir = checked["run_path"] or workdir
+        for cand in sorted(Path(run_dir).glob("RUN_*/summary.md")):
+            summary = cand.read_text(errors="replace")
+            run_dir = str(cand.parent)
+            break
+        return {"exit_code": proc.returncode, "stdout": proc.stdout,
+                "stderr": proc.stderr, "summary_md": summary,
+                "run_dir": run_dir}
+
+    def parse(self, native_output):
+        """Parse summary.md status cells to pass/fail verdict.
+
+        Args:
+            native_output: Native output with summary markdown.
+
+        Returns:
+            {total, violations[], source}.
+
+        Raises:
+            AdapterError: runner_unavailable with no summary.
+        """
+        summary = native_output.get("summary_md")
+        if not summary or not _STATUS_RE.search(summary):
+            raise AdapterError(
+                "runner_unavailable", "Cace run left no summary.md.")
+        bad = [m for m in ("Fail", "Error") if m.lower() in summary.lower()]
+        if native_output.get("exit_code", 0) not in (0,) or bad:
+            fails = [line.strip() for line in summary.splitlines()
+                     if "Fail" in line or "Error" in line]
+            violations = [{"rule": "characterize_fail", "severity": "error",
+                           "message": line[:300] or "Cace spec miss."}
+                          for line in fails] or [{
+                              "rule": "characterize_fail",
+                              "severity": "error",
+                              "message": "Cace run failed."}]
+            return {"total": len(violations), "violations": violations,
+                    "source": "summary_md"}
+        return {"total": 0, "violations": [], "source": "summary_md"}

rocket_engine/adapters/circulax/README.md

@@ -0,0 +1,10 @@
+# Circulax time-domain adapter
+
+The Circulax package has two roles:
+
+- Its RC step smoke qualifies the installed library with a small, known-good and known-bad circuit. It returns solver version, time samples, capacitor voltage, and final voltage.
+- CirculaxAdapter is registered for the run_optical operation as the circulax deck tool. Engine jobs provide the simulation inputs and receive normalized results.
+
+The smoke uses a voltage step, resistor, and capacitor compiled through kfnetlist. With Circulax 0.2.5, the 1 kΩ / 1 nF case reaches 0.9933 V at 5 μs; the 100 kΩ / 1 nF case reaches 0.0488 V and misses the threshold. A missing Circulax dependency reports missing_dependency rather than a fabricated verdict.
+
+See [adapter.py](adapter.py) and the [solver map](../README.md).

rocket_engine/adapters/circulax/__init__.py

@@ -0,0 +1,112 @@
+"""Circulax time-domain smoke: smallest honest RC transient.
+
+A V step driving R + C to GND, compiled via kfnetlist and run with
+`Circuit.transient` from a discharged (`y0=zeros`) start. Verified
+against circulax 0.2.5: good RC (1k/1nF, tau=1us) charges
+Vc(1us)=0.6321, Vc(5us)=0.9933; slow RC (100k/1nF) sits at 0.0488.
+The same 0.9 V @5us threshold passes the good run and fails the slow
+run — the good-vs-bad signal. Solver imports stay lazy so bare envs
+fail loud (`missing_dependency`), never fake-green. A full
+`deck.tool: circulax` Engine adapter is follow-up, out of scope.
+"""
+
+from ..errors import AdapterError
+
+CIRCULAX_PIN = "0.2.5"
+
+
+def circulax_version():
+    """Proven solver version, observable per run (uv.lock pin).
+
+    Returns:
+        Installed circulax version, or "unknown" when the package
+            carries no version attribute.
+
+    Raises:
+        AdapterError: missing_dependency when circulax is not
+            importable.
+    """
+    try:
+        import circulax
+    except ImportError as exc:
+        raise AdapterError(
+            "missing_dependency",
+            f"circulax is not importable: {exc} "
+            "(uv sync).",
+        ) from exc
+    return getattr(circulax, "__version__", "unknown")
+
+
+def run_rc_step(*, R=1e3, C=1e-9, V=1.0, t1=5e-6, points=11, dt0=1e-8):
+    """Run the RC step transient live; return the cap voltage trace.
+
+    Args:
+        R: Resistance in ohms (positive).
+        C: Capacitance in farads (positive).
+        V: Step voltage in volts.
+        t1: End time in seconds (positive).
+        points: Samples on the grid (at least 2).
+        dt0: Initial solver step in seconds (positive).
+
+    Returns:
+        `{circulax_version, R, C, V, t_s[], vc_V[], final_V}` —
+            plain floats, JSON-friendly.
+
+    Raises:
+        AdapterError: invalid_command on bad parameters,
+            missing_dependency where circulax is uninstalled.
+    """
+    if not R > 0 or not C > 0 or not t1 > 0 or not dt0 > 0:
+        raise AdapterError(
+            "invalid_command",
+            f"RC step needs positive R/C/t1/dt0, got R={R!r} C={C!r} "
+            f"t1={t1!r} dt0={dt0!r}.",
+        )
+    if not isinstance(points, int) or points < 2:
+        raise AdapterError(
+            "invalid_command", f"RC step needs points >= 2, got {points!r}."
+        )
+    try:
+        import jax.numpy as jnp
+        import kfnetlist as kfnl
+        from circulax import compile_circuit
+        from circulax.components.electronic import (
+            Capacitor,
+            Resistor,
+            VoltageSource,
+        )
+    except ImportError as exc:
+        raise AdapterError(
+            "missing_dependency",
+            f"circulax is not importable: {exc} "
+            "(uv sync).",
+        ) from exc
+    netlist = kfnl.Netlist()
+    netlist.create_inst(name="V1", kcl="", component="vsource", settings={"V": V})
+    netlist.create_inst(name="R1", kcl="", component="resistor", settings={"R": R})
+    netlist.create_inst(name="C1", kcl="", component="capacitor", settings={"C": C})
+    netlist.create_inst(name="GND", kcl="", component="ground")
+    netlist.create_net(kfnl.PortRef("V1", "p1"), kfnl.PortRef("R1", "p1"))
+    netlist.create_net(kfnl.PortRef("V1", "p2"), kfnl.PortRef("GND", "p1"))
+    netlist.create_net(kfnl.PortRef("R1", "p2"), kfnl.PortRef("C1", "p1"))
+    netlist.create_net(kfnl.PortRef("C1", "p2"), kfnl.PortRef("GND", "p1"))
+    circuit = compile_circuit(
+        netlist,
+        {"vsource": VoltageSource, "resistor": Resistor, "capacitor": Capacitor},
+    )
+    grid = jnp.linspace(0, t1, points)
+    solution = circuit.transient(
+        t0=0.0, t1=t1, dt0=dt0, saveat=grid, y0=jnp.zeros(circuit.sys_size)
+    )
+    cap = circuit.port_map["C1,p1"]
+    times = [float(t) for t in solution.ts]
+    voltages = [float(row[cap]) for row in solution.ys]
+    return {
+        "circulax_version": circulax_version(),
+        "R": R,
+        "C": C,
+        "V": V,
+        "t_s": times,
+        "vc_V": voltages,
+        "final_V": voltages[-1],
+    }

rocket_engine/adapters/circulax/_driver.py

@@ -0,0 +1,190 @@
+"""Staged circulax sim driver: job JSON in, result envelope JSON on stdout.
+
+The adapter copies this file into the run workdir next to
+`circulax_job.json` and executes `python circulax_driver.py
+circulax_job.json`. One marker-delimited JSON envelope is printed to stdout
+(ROCKETEDA_ENVELOPE_BEGIN/END); chatter outside the markers is
+tolerated and stays in logs.
+
+The netlist is built from the project spec (`doc` instances +
+connections + transient): nothing is hardcoded — R/C/V, the
+topology, the time grid, and the observed port all ride the job.
+Only the proven transient path runs (`Circuit.transient` from a
+discharged start); DC/AC/harmonic-balance stay refused in the
+adapter until a proof lands.
+
+Envelope: `{"ok": true, "circulax_version, "result": {t_s[],
+v_V[], final_V, observe, t1_s, points}}` or `{"ok": false, "error":
+{code, message, token, line}}`. Exit 0 on sim success, 2 on a
+malformed circuit, 3 when circulax is not importable. Anything else
+explodes with a traceback and exit 1, which parse() reports as
+runner_unavailable rather than mistaking a tool crash for physics.
+"""
+
+import json
+import re
+import sys
+
+_ENVELOPE_BEGIN = "ROCKETEDA_ENVELOPE_BEGIN"
+_ENVELOPE_END = "ROCKETEDA_ENVELOPE_END"
+
+_QUOTED_RE = re.compile(r"""['\"]([^'\"]+)['\"]""")
+
+_COMPONENTS = ("vsource", "resistor", "capacitor", "ground")
+
+
+def _token(doc, message):
+    instances = doc.get("instances") or {}
+    names = list(instances)
+    names.extend(list(_COMPONENTS))
+    for name in names:
+        if name and re.search(r"\b" + re.escape(name) + r"\b", message):
+            return name
+    for match in _QUOTED_RE.finditer(message):
+        return match.group(1)
+    return None
+
+
+def _find_line(text, token):
+    if not token:
+        return None
+    for number, line in enumerate(text.splitlines(), 1):
+        if token in line:
+            return number
+    return None
+
+
+def _fail(code, message, token, line):
+    print(_ENVELOPE_BEGIN)
+    print(
+        json.dumps(
+            {
+                "ok": False,
+                "error": {
+                    "code": code,
+                    "message": message,
+                    "token": token,
+                    "line": line,
+                },
+            }
+        )
+    )
+    print(_ENVELOPE_END)
+
+
+def main(argv):
+    # TODO: why is the output stdout??!!!! reserve the json, pass the python object as is back to the adapter level, and it will fanout from there to any active adapter who is responsible for formatting said outputs!!!!
+    """Run one staged circulax transient: job JSON in, envelope on stdout.
+
+    Args:
+        argv: Argument vector; argv[1] is the staged job JSON path.
+
+    Returns:
+        Process exit code: 0 on sim success, 2 on a malformed
+            circuit, 3 when circulax is not importable.
+
+    Raises:
+        ValueError: Unknown component or bad observe port (raised
+            and caught inside main into the invalid_circuit
+            envelope — never escapes).
+    """
+    with open(argv[1], encoding="utf-8") as handle:
+        job = json.load(handle)
+    text = job.get("text", "")
+    doc = job["doc"]
+    try:
+        import jax.numpy as jnp
+        import kfnetlist as kfnl
+        from circulax import compile_circuit
+        from circulax.components.electronic import (
+            Capacitor,
+            Resistor,
+            VoltageSource,
+        )
+    except ImportError as exc:
+        _fail(
+            "missing_dependency",
+            f"circulax is not importable: {exc} "
+            "(uv sync).",
+            None,
+            None,
+        )
+        return 3
+    try:
+        import circulax
+
+        classes = {
+            "vsource": VoltageSource,
+            "resistor": Resistor,
+            "capacitor": Capacitor,
+        }
+        netlist = kfnl.Netlist()
+        for name, inst in doc["instances"].items():
+            component = inst["component"]
+            if component not in _COMPONENTS:
+                raise ValueError(f"Unknown component: {component!r}.")
+            netlist.create_inst(
+                name=name,
+                kcl="",
+                component=component,
+                settings=dict(inst.get("settings") or {}),
+            )
+        for left, right in (doc.get("connections") or {}).items():
+            left_inst, _, left_port = left.partition(",")
+            right_inst, _, right_port = right.partition(",")
+            netlist.create_net(
+                kfnl.PortRef(left_inst, left_port),
+                kfnl.PortRef(right_inst, right_port),
+            )
+        circuit = compile_circuit(
+            netlist,
+            {key: classes[key] for key in classes},
+        )
+        transient = doc["transient"]
+        t1 = float(transient["t1_s"])
+        points = int(transient["points"])
+        dt0 = float(transient.get("dt0_s", 1e-8))
+        observe = transient["observe"]
+        if observe not in circuit.port_map:
+            raise ValueError(f"Unknown observe port: {observe!r}.")
+        grid = jnp.linspace(0, t1, points)
+        solution = circuit.transient(
+            t0=0.0,
+            t1=t1,
+            dt0=dt0,
+            saveat=grid,
+            y0=jnp.zeros(circuit.sys_size),
+        )
+        index = circuit.port_map[observe]
+        times = [float(t) for t in solution.ts]
+        volts = [float(row[index]) for row in solution.ys]
+    except (ValueError, KeyError, TypeError) as exc:
+        message = f"{type(exc).__name__}: {exc}"
+        token = _token(doc, message)
+        _fail("invalid_circuit", message, token, _find_line(text, token))
+        return 2
+    print(_ENVELOPE_BEGIN)
+    print(
+        json.dumps(
+            {
+                "ok": True,
+                "circulax_version": getattr(
+                    circulax, "__version__", "unknown"
+                ),
+                "result": {
+                    "t_s": times,
+                    "v_V": volts,
+                    "final_V": volts[-1],
+                    "observe": observe,
+                    "t1_s": t1,
+                    "points": points,
+                },
+            }
+        )
+    )
+    print(_ENVELOPE_END)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))