INTERLIS leicht gemacht #53 - INTERLIS-Compiler-Bindings für Python und Node.js

npm install ili2c

const ili2c = require('ili2c');
const result = ili2c.compileModel("test/Test1.ili", "ili2c.log");

@CEntryPoint(name = "compileModel")
public static int compileModel(IsolateThread thread, CCharPointer iliFile, CCharPointer logFile) {
    String iliFileStr = CTypeConversion.toJavaString(iliFile);
    String logFileStr = CTypeConversion.toJavaString(logFile);
    return compileModelImpl(iliFileStr, logFileStr);
}

public static int compileModelImpl(String iliFile, String logFile) {
    try {
        Files.deleteIfExists(new File(logFile).toPath());
    } catch (IOException e) {
        e.printStackTrace();
    }
    FileLogger fileLogger = new FileLogger(new File(logFile), false);
    EhiLogger.getInstance().addListener(fileLogger);

    EhiLogger.logState("ili2c-"+TransferDescription.getVersion());
    EhiLogger.logState("ilifile <" + iliFile + ">");

    IliManager manager = new IliManager();
    manager.setRepositories(Ili2cSettings.DEFAULT_ILIDIRS.split(";"));
    ArrayList<String> iliFiles = new ArrayList<String>();
    iliFiles.add(iliFile);
    Configuration config;
    try {
        config = manager.getConfigWithFiles(iliFiles);
    } catch (Ili2cException e) {
        EhiLogger.getInstance().removeListener(fileLogger);
        fileLogger.close();
        return 1;
    }

    DateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date today = new Date();
    String dateOut = dateFormatter.format(today);

    TransferDescription td = null;
    try {
        td = ch.interlis.ili2c.Ili2c.runCompiler(config);
    } catch (Ili2cFailure e) {
        EhiLogger.logError("...compiler run failed " + dateOut);
        EhiLogger.getInstance().removeListener(fileLogger);
        fileLogger.close();
        return 1;
    }

    EhiLogger.logState("...compiler run done " + dateOut);
    EhiLogger.getInstance().removeListener(fileLogger);
    fileLogger.close();
    return 0;
}

Napi::Value CompileModel(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();

    if (thread == nullptr) {
        Napi::Error::New(env, "Isolate not initialized. Call initIsolate first.").ThrowAsJavaScriptException();
        return env.Null();
    }

    if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
        Napi::TypeError::New(env, "Expected (string iliFile, string logFile)").ThrowAsJavaScriptException();
        return env.Null();
    }

    std::string iliFile = info[0].As<Napi::String>();
    std::string logFile = info[1].As<Napi::String>();

    int res = compileModel(thread, const_cast<char*>(iliFile.c_str()), const_cast<char*>(logFile.c_str()));

    if (res < 0) {
        Napi::Error::New(env, "compileModel critical failure with code: " + std::to_string(res)).ThrowAsJavaScriptException();
        return env.Null();
    }

    // 0 means success, 1 means model compile failure
    return Napi::Boolean::New(env, res == 0);
}

const path = require('path');

const platform = process.platform;
const arch = process.arch;

let runtime = "node";
if (process.versions.electron) {
  runtime = "electron";
}

if (process.platform === "win32") {
  const dllFolder = path.join(__dirname, 'prebuilds', `${platform}-${arch}`);
  process.env.PATH = `${dllFolder};${process.env.PATH}`;
}

const nativePath = path.join(__dirname, 'prebuilds', `${platform}-${arch}`, runtime, 'ili2c.node');
const native = require(nativePath);

let initialized = false;

// wrapper function that automatically handles isolate
function compileModel(iliFile, logFile) {
  if (!initialized) {
    native.initIsolate();
    initialized = true;
  }
  return native.compileModel(iliFile, logFile);
}

function prettyPrint(iliFile) {
  if (!initialized) {
    native.initIsolate();
    initialized = true;
  }
  return native.prettyPrint(iliFile);
}

// auto-teardown on exit
process.on('exit', () => {
  if (initialized) {
    native.tearDownIsolate();
  }
});

module.exports = {
  compileModel, prettyPrint
};

  "dependencies": {
    "ili2c": "^0.0.27",
  }

  "scripts": {
    "vscode:prepublish": "npm run package && mkdir -p dist/prebuilds && cp -r node_modules/ili2c/prebuilds/* dist/prebuilds/",
    ...
    "watch": "mkdir -p dist/prebuilds && cp -r node_modules/ili2c/prebuilds/* dist/prebuilds/ && npm-run-all -p watch:*",
    ...
  }

from ctypes import *
from importlib_resources import files
import platform

if platform.uname()[0] == "Windows":
    lib_name = "libili2c.dll"
elif platform.uname()[0] == "Linux":
    lib_name = "libili2c.so"
else:
    lib_name = "libili2c.dylib"

class Ili2c:
    @staticmethod
    def create_ilismeta16(iliFile: str, xtfFile: str) -> bool:
        lib_path = files('ili2c.lib_ext').joinpath(lib_name)
        # str() seems to be necessary on windows: https://github.com/TimDettmers/bitsandbytes/issues/30
        dll = CDLL(str(lib_path))
        isolate = c_void_p()
        isolatethread = c_void_p()
        dll.graal_create_isolate(None, byref(isolate), byref(isolatethread))

        try:
            result = dll.createIlisMeta16(isolatethread, c_char_p(bytes(iliFile, "utf8")), c_char_p(bytes(xtfFile, "utf8")))
            return result == 0
        finally:
            dll.graal_tear_down_isolate(isolatethread)

    @staticmethod
    def compile_model(iliFile: str, logFile: str) -> bool:
        lib_path = files('ili2c.lib_ext').joinpath(lib_name)
        dll = CDLL(str(lib_path))
        isolate = c_void_p()
        isolatethread = c_void_p()
        dll.graal_create_isolate(None, byref(isolate), byref(isolatethread))

        try:
            result = dll.compileModel(isolatethread, c_char_p(bytes(iliFile, "utf8")), c_char_p(bytes(logFile, "utf8")))
            return result == 0
        finally:
            dll.graal_tear_down_isolate(isolatethread)

    @staticmethod
    def pretty_print(iliFile: str) -> bool:
        lib_path = files('ili2c.lib_ext').joinpath(lib_name)
        dll = CDLL(str(lib_path))
        isolate = c_void_p()
        isolatethread = c_void_p()
        dll.graal_create_isolate(None, byref(isolate), byref(isolatethread))

        try:
            result = dll.prettyPrint(isolatethread, c_char_p(bytes(iliFile, "utf8")))
            return result == 0
        finally:
            dll.graal_tear_down_isolate(isolatethread)

pip install ili2c

from ili2c import Ili2c
result = Ili2c.compile_model("test/Test1.ili", "ili2c.log")
print(result)

xquery version "3.1";

declare namespace ili = "http://www.interlis.ch/xtf/2.4/INTERLIS";
declare namespace IlisMeta16 = "http://www.interlis.ch/xtf/2.4/IlisMeta16";

let $modelTid := "SO_ARP_SEin_Konfiguration_20250115"
let $classes :=
  //IlisMeta16:Class[
    starts-with(@ili:tid, concat($modelTid, ".")) and
    IlisMeta16:Kind = 'Class'
  ]

return
  string-join(
    for $cls in $classes
    let $clsName := $cls/IlisMeta16:Name/text()
    let $clsTid := string($cls/@ili:tid)
    let $attrs := //IlisMeta16:AttrOrParam[IlisMeta16:AttrParent/@ili:ref = $clsTid]
    return
      string-join((
        "from dataclasses import dataclass",
        "from typing import Optional",
        "",
        "@dataclass",
        "class " || $clsName || ":",
        if (empty($attrs)) then
          "    pass"
        else
          string-join(
            for $attr in $attrs
            let $attrName := $attr/IlisMeta16:Name/text()
            let $doc := normalize-space($attr//IlisMeta16:Text/text())
            let $typeRef := $attr/IlisMeta16:Type/@ili:ref
            let $typeEl := //*[namespace-uri() = 'http://www.interlis.ch/xtf/2.4/IlisMeta16' and @ili:tid = $typeRef]
            let $typeKind := name($typeEl)
            let $pyType :=
              if ($typeKind = 'IlisMeta16:TextType') then "str"
              else if ($typeKind = 'IlisMeta16:NumType') then "float"
              else if ($typeKind = 'IlisMeta16:DateType') then "str" (: or use date :)
              else "Optional[str]" (: default fallback :)
            return
              "    " || $attrName || ": " || $pyType || (
                if ($doc) then "  # " || $doc else ""
              )
          , codepoints-to-string(10))  (: newline :)
      ), codepoints-to-string(10))
  , codepoints-to-string(10) || codepoints-to-string(10))  (: double newline between classes :)

from dataclasses import dataclass
from typing import Optional

@dataclass
class Gemeinde:
    Name: str  # Name der Gemeinde (gemäss amtlichem Verzeichnis)
    BFSNr: float  # Offizielle Gemeindenummer
    Geometrie: Optional[str]  # Geometrie
    Bezirk: str  # Name des Bezirks
    Handlungsraum: Optional[str]

from dataclasses import dataclass
from typing import Optional

@dataclass
class Gemeinde:
    BoundingBox: str  # Ausdehnung / Bounding Box
    Gruppen: Optional[str]  # Liste sämtlicher Themen-Gruppen.

from dataclasses import dataclass
from typing import Optional

@dataclass
class Gemeinde:
    pass

from dataclasses import dataclass
from typing import Optional

@dataclass
class Gruppe:
    pass

from dataclasses import dataclass
from typing import Optional

@dataclass
class Objektinfo:
    pass

from dataclasses import dataclass
from typing import Optional

@dataclass
class Thema:
    pass