added simple template generator frontend

- added a few new list/skip/force options to the generator

Author: nopeslide

scripts/gen_template.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+
+DOMAIN=$1
+OPERATOR=$2
+VERSION=$3
+
+ROOT=$(git rev-parse --show-toplevel)
+cd $ROOT/scripts
+
+if [[ -z $DOMAIN ]]
+then
+    echo "usage: $0 [domain] [operator] [version]"
+    echo "possible domains:"
+    python3 -m onnx_generator \
+        --list-domains \
+        -- ..
+    exit 1
+fi
+
+if [[ -z $OPERATOR ]]
+then
+    echo "usage: $0 [domain] [operator] [version]"
+    echo "possible operators:"
+    if ! python3 -m onnx_generator \
+        --list-operators \
+        --domains $DOMAIN \
+        -- ..
+    then
+        echo "no operators found! check specified domain!"
+    fi
+    exit 1
+fi
+
+if [[ -z $VERSION ]]
+then
+    echo "usage: $0 [domain] [operator] [version]"
+    echo "possible versions:"
+    if ! python3 -m onnx_generator \
+        --list-versions \
+        --domains $DOMAIN \
+        -i '^'$OPERATOR'$' \
+        -- ..
+    then
+        echo "no versions found! check specified domain and operator!"
+    fi
+    exit 1
+fi
+
+RESULT=$(python3 -m onnx_generator \
+    --list-versions \
+    --domains $DOMAIN \
+    -i '^'$OPERATOR'$' \
+    --version $VERSION \
+    -- ..)
+if [[ $RESULT != $@ ]]
+then
+    echo "could not find combination of specified domain, operator and version!"
+    exit 1
+fi
+
+echo "### GENERATING TEMPLATE FOR $@ ###"
+echo
+python3 -m onnx_generator -vv \
+    --domains $DOMAIN \
+    -i '^'$OPERATOR'$' \
+    --version $VERSION \
+    --no-sets \
+    -- ..
+echo
+
+OPERATORS=
+echo "### GENERATING NEW OPERATOR SET ###"
+echo
+python -m onnx_generator -v \
+    -i $(find ../src/operators -maxdepth 2 -mindepth 2 -type d -printf "^%f$ " )\
+    --version latest \
+    --force-pattern \
+        '^'$ROOT'/src/operators/'$DOMAIN'/opdomain_.*$' \
+        '^'$ROOT'/src/operators/operator_set.c$' \
+    --skip-pattern '.*' \
+    -- ..

scripts/onnx_generator/__main__.py

@@ -14,6 +14,33 @@
     default=args.force,
     help="overwrite existing files"
 )
+parser.add_argument(
+    "--list-domains",
+    action='count',
+    help="list all domains"
+)
+parser.add_argument(
+    "--list-operators",
+    action='count',
+    help="list all operators in selected domains"
+)
+parser.add_argument(
+    "--list-versions",
+    action='count',
+    help="list all versions of selected operators in selected domains"
+)
+parser.add_argument(
+    "--skip-pattern",
+    nargs="+",
+    default=args.skip_pattern,
+    help="skip path matching pattern"
+)
+parser.add_argument(
+    "--force-pattern",
+    nargs="+",
+    default=args.force_pattern,
+    help="for write of path matching pattern"
+)
 parser.add_argument(
     "--force-header",
     action='count',

scripts/onnx_generator/args.py

@@ -2,6 +2,8 @@
 onnx = []
 verbose = 0
 header = ["src/operators"]
+skip_pattern = []
+force_pattern = []
 no_header = 0
 force_header = 0
 resolve = ["src/operators/"]

scripts/onnx_generator/run.py

@@ -49,7 +49,7 @@ def fatal(text, error=1):
     version2schema = name2version2schema.setdefault(schema.name,{})
     version2schema[schema.version] = schema
 
-note("selecting domains")
+note("selecting domains",1)
 domains = domain2name2version2schema.keys()
 note(f"onnx operator schemas have {len(domains)} domains: {', '.join(domains)}",2)
 if "all" in args.domains:
@@ -101,7 +101,7 @@ def fatal(text, error=1):
     for name in names:
         del domain2name2version2schema[domain][name]
 
-note("selecting onnx operator schema versions")
+note("selecting onnx operator schema versions",1)
 delete_versions = {}
 for domain, name2version2schema in domain2name2version2schema.items():
     for name, version2schema in name2version2schema.items():
@@ -134,6 +134,25 @@ def fatal(text, error=1):
         for schema in version2schema.values():
             schemas.append(schema)
 
+if args.list_domains or args.list_operators or args.list_versions:
+    empty = True
+    for domain, name2version2schema in domain2name2version2schema.items():
+        if args.list_domains:
+            empty = False
+            print(domain)
+        for name, version2schema in name2version2schema.items():
+            if args.list_operators:
+                empty = False
+                print(f"{domain} {name}")
+            for version in version2schema.keys():
+                if args.list_versions:
+                    empty = False
+                    print(f"{domain} {name} {version}")
+    if empty:
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
 note("generating onnx operator headers")
 path = f"{args.path[-1]}/{args.header[-1]}/"
 headers = [ OperatorHeader.Header(s,path) for s in schemas ]
@@ -162,18 +181,39 @@ def fatal(text, error=1):
     files.extend(map(lambda x: (bool(args.force_info),x),info))
 
 writecount = 0
+existcount = 0
+skipcount = 0
 note("Writing files",1)
 if not args.path[-1]:
     warning("skipping write because args.path is not set")
 else:
     for force,obj in files:
         path = obj.filepath()
-        if path.exists() and not (args.force or force):
-            warning(f"skipping existing file '{path}'",1)
-            continue
-        note(f"writing file {path}",3)
+        overwrite = args.force or force
+        if not overwrite:
+            for pattern in args.force_pattern:
+                if re.match(pattern,str(path)):
+                    overwrite=True
+                    break
+        skip = False
+        for pattern in args.skip_pattern:
+            if re.match(pattern,str(path)):
+                skip = True
+                break
+        if not overwrite:
+            if path.exists():
+                existcount += 1
+                warning(f"skipping existing file '{path}'",2)
+                continue
+            elif skip:
+                skipcount += 1
+                warning(f"skipping file '{path}'",2)
+                continue
+            note(f"writing file {path}",1)
+        else:
+            warning(f"overwriting file {path}",1)
         if not args.dryrun:
             os.makedirs(path.parent,exist_ok=True)
             path.open("w").write(str(obj))
         writecount += 1
-note(f"wrote {writecount} of {len(files)} files")
+note(f"wrote {writecount} of {len(files)} files ({existcount} already existed, {skipcount} skipped)")