master > master: code - umgang mit cli args vereinheitlicht

code/golang/internal/setup/cli/cli.go

@@ -68,7 +68,10 @@ var optionsConfigFile = argparse.Options{
 // Parst cli flags.
 func ParseCli(args []string) (*types.CliArguments, error) {
 	var err error
-	Parser = argparse.NewParser("cli parser", "Liest Optionen + Flags von Kommandozeile.")
+	Parser = argparse.NewParser(
+		"cli parser",
+		"\033[93;2mEin Programm zur Ausführung verschiedener Algorithmen aus dem Kurs AlgoDat I.\033[0m",
+	)
 	arguments := types.CliArguments{
 		ModeHelp:    Parser.NewCommand("help", "Hilfsanleitung anzeigen"),
 		ModeVersion: Parser.NewCommand("version", "Version anzeigen."),

code/golang/internal/setup/setup_assets.go

@@ -38,7 +38,7 @@ func ReadAsset(key string) string {
 }
 
 /* ---------------------------------------------------------------- *
- * METHODS templates
+ * METHODS assets
  * ---------------------------------------------------------------- */
 
 func Help() string {

code/golang/main.go

@@ -38,9 +38,11 @@ var (
  * ---------------------------------------------------------------- */
 
 func main() {
-	var err error
 	var arguments *types.CliArguments
 	var (
+		err1       error
+		err2       error
+		err3       error
 		cmdMissing bool
 		showChecks bool
 	)
@@ -50,12 +52,12 @@ func main() {
 	setup.Assets = assets
 
 	// cli arguments parsen
-	arguments, err = cli.ParseCli(os.Args)
+	arguments, err1 = cli.ParseCli(os.Args)
-	cmdMissing = cli.ParseCliCommandMissing(err)
+	cmdMissing = cli.ParseCliCommandMissing(err1)
 
-	// initialisiere basic optionen wie Logging
+	// Programmeinstellungen initialisieren
 	showChecks = false
-	if err == nil {
+	if err1 == nil {
 		if !(arguments.ModeRun.Happened() && arguments.InteractiveMode()) {
 			logging.SetQuietMode(arguments.QuietModeOn())
 			logging.SetDebugMode(arguments.DebugModeOn())
@@ -63,34 +65,39 @@ func main() {
 		logging.SetAnsiMode(arguments.ShowColour())
 		showChecks = arguments.ShowChecks()
 	}
-
+	err2 = setup.AppConfigInitialise()
-	// app config (intern) intialisieren
-	err = setup.AppConfigInitialise()
 	setup.SetAppConfigPerformChecks(showChecks)
 
-	if err == nil {
+	// Fehler melden (fatal)
-		if arguments.ModeVersion.Happened() {
+	if err1 != nil && !cmdMissing {
-			endpoints_print.Version()
+		logging.Fatal(err1)
-			return
+	}
-		} else if arguments.ModeRun.Happened() {
+	if err2 != nil {
-			if arguments.InteractiveMode() {
+		logging.Fatal(err2)
-				endpoints_run.RunInteractive()
+	}
-			} else {
+	// Wenn der Artefakt ohne Argument aufgerufen wird, keinen Fehler melden, sondern im it-Modus ausführen
-				err = endpoints_run.RunNonInteractive(arguments.GetConfigFile())
+	if cmdMissing {
-				if err != nil {
-					logging.Fatal(err)
-				}
-			}
-			return
-		} else if arguments.ModeHelp.Happened() {
-			endpoints_print.Help()
-			return
-		} else {
-			endpoints_run.RunInteractive()
-		}
-	} else if cmdMissing {
 		endpoints_run.RunInteractive()
+		return
+	}
+	// Sonst Commands behandeln
+	if arguments.ModeHelp.Happened() {
+		endpoints_print.Help()
+		return
+	} else if arguments.ModeVersion.Happened() {
+		endpoints_print.Version()
+		return
+	} else if arguments.ModeRun.Happened() {
+		if arguments.InteractiveMode() {
+			endpoints_run.RunInteractive()
+		} else {
+			err3 = endpoints_run.RunNonInteractive(arguments.GetConfigFile())
+			if err3 != nil {
+				logging.Fatal(err3)
+			}
+		}
+		return
 	} else {
-		logging.Fatal(err)
+		endpoints_run.RunInteractive()
 	}
 }

code/python/src/__main__.py

@@ -17,6 +17,7 @@ import sys;
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.abspath(__file__), '..')));
 
 from src.setup.cli import *;
+from src.endpoints.exports import *;
 from src.main import enter;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -24,10 +25,18 @@ from src.main import enter;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 if __name__ == '__main__':
-    sys.tracebacklimit = 0;
     sys.tracebacklimit = 0;
     try:
-        args = GetArgumentsFromCli(sys.argv[1:]);
+        args = GetArgumentsFromCli(*sys.argv[1:]);
     except:
+        endpoint_help();
         exit(1);
-    enter(quiet=args.quiet, debug=args.debug, mode=args.mode[0], path=args.path);
+    enter(
+        mode=args.mode,
+        it=args.it,
+        quiet=args.quiet,
+        debug=args.debug,
+        checks=args.checks,
+        colour=args.colour,
+        config=args.config,
+    );

code/python/src/endpoints/print.py

@@ -6,17 +6,14 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.core.log import *;
-from src.setup.cli import GetArgumentsFromCli;
+from src.setup import assets;
-from src.setup.cli import GetArgumentParser;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # ENDPOINT version
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def version():
-    with open('assets/VERSION', 'r') as fp:
+    logPlain(assets.Version());
-        version = ('\n'.join(fp.readlines())).strip();
-    logPlain(version);
     return;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -24,6 +21,5 @@ def version():
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def help():
-    parser = GetArgumentParser();
+    logPlain(assets.Help());
-    parser.print_help();
     return;

code/python/src/endpoints/run.py

@@ -8,6 +8,7 @@
 from src.core.log import *;
 from src.core.config import *;
 from src.setup.display import *;
+from src.setup import assets;
 from src.algorithms.exports import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -18,6 +19,7 @@ def runInteractive():
     '''
     Startet Programm im interaktiven Modus (Konsole).
     '''
+    logPlain(assets.Logo());
     logWarn('Interaktiver Modus noch nicht implementiert.');
     return;
 
@@ -31,6 +33,7 @@ def runNonInteractive(path: str):
     '''
     config = ReadConfigFile(path);
     cases = GetAttribute(config, 'parts', 'cases', expectedtype=list, default=[]);
+    logPlain(assets.Logo());
     for caseindex, case in enumerate(cases):
         command = GetAttribute(case, 'command', expectedtype=str, default='');
         descr = GetAttribute(case, 'description', expectedtype=str, default='');

code/python/src/main.py

@@ -13,8 +13,6 @@ sys.path.insert(0, _path_to_python_project);
 os.chdir(_path_to_python_project);
 
 from src.core.log import *;
-from src.core.utils import IsTrue;
-from src.core.utils import IsFalse;
 from src.setup.cli import *;
 from src.setup import appconfig;
 from src.endpoints.exports import *;
@@ -30,14 +28,16 @@ PATH_TO_CONFIG: str = '../config.yml';
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def enter(
-    mode: str,
+    mode: Union[str, None],
     it: bool,
     quiet: bool,
     debug: bool,
     checks: bool,
     colour: bool,
-    config: Any, **_
+    config: Union[str, None],
+    **_
 ):
+    # Programmeinstellungen initialisieren
     if not (mode == 'run' and it):
         SetQuietMode(quiet);
         SetDebugMode(debug);
@@ -46,7 +46,15 @@ def enter(
 
     config = config if isinstance(config, str) else PATH_TO_CONFIG;
 
-    if mode == 'version':
+    # Wenn der Artefakt ohne Argument aufgerufen wird, keinen Fehler melden, sondern im it-Modus ausführen
+    if mode is None:
+        endpoint_runInteractive();
+        return;
+    # Sonst Commands behandeln
+    if mode == 'help':
+        endpoint_help();
+        return;
+    elif mode == 'version':
         endpoint_version();
         return;
     elif mode == 'run':
@@ -54,8 +62,9 @@ def enter(
             endpoint_runInteractive();
         else:
             endpoint_runNonInteractive(path=config);
-    else: # elif mode
+        return;
-        endpoint_help();
+    else:
+        endpoint_runInteractive();
         return;
     return;
 
@@ -71,11 +80,11 @@ if __name__ == '__main__':
         endpoint_help();
         exit(1);
     enter(
-        mode=args.mode[0],
+        mode=args.mode,
         it=args.it,
         quiet=args.quiet,
         debug=args.debug,
-        checks=IsTrue(args.checks[0]),
+        checks=args.checks,
-        colour=IsTrue(args.colour[0]),
+        colour=args.colour,
         config=args.config,
     );

code/python/src/setup/assets.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.local.io import *;
+
+from src.core.utils import DedentIgnoreFirstLast
+from src.setup.cli import GetArgumentParser;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHODS assets
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def Help() -> str:
+    parser = GetArgumentParser();
+    with io.StringIO() as fp:
+        parser.print_help(fp)
+        text = fp.getvalue();
+    return text;
+
+def Logo() -> str:
+    ## NOTE: expandiert ansi nicht:
+    # with open('assets/LOGO', 'r') as fp:
+    #     logo = (''.join(fp.readlines())).strip();
+    logo = DedentIgnoreFirstLast('''
+    +--------------------+
+    |      \033[32;1mAlgoDat I\033[0m     |
+    +--------------------+
+    ''') + '\n';
+    return logo;
+
+def Version() -> str:
+    with open('assets/VERSION', 'r') as fp:
+        version = (''.join(fp.readlines())).strip();
+    return version;

code/python/src/setup/cli.py

@@ -10,6 +10,8 @@ from src.local.typing import *;
 
 from src.core.log import *;
 from src.core.utils import DedentIgnoreFirstLast;
+from src.core.utils import IsTrue;
+from src.core.utils import IsFalse;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # GLOBAL VARIABLES
@@ -28,12 +30,12 @@ def GetArgumentParser() -> argparse.ArgumentParser:
             prog='code/main.py',
             description=DedentIgnoreFirstLast('''
             \033[93;1mBeschreibung:\033[0m
-            \033[93;2mEin Programm, das verschiedene Algorithmen aus dem Kurs AlgoDat I testet.\033[0m
+            \033[93;2mEin Programm zur Ausführung verschiedener Algorithmen aus dem Kurs AlgoDat I.\033[0m
             '''),
             formatter_class=argparse.RawTextHelpFormatter,
         );
         parser.add_argument('mode',
-            nargs=1,
+            nargs='?',
             choices=['version', 'help', 'run'],
             help=DedentIgnoreFirstLast('''
             help    = Hilfsanleitung anzeigen.
@@ -51,9 +53,12 @@ def GetArgumentParser() -> argparse.ArgumentParser:
             '''),
         ),
         parser.add_argument('--colour', nargs=1, type=str, default=['False'], help='(bool)   Ob Logging färblich angezeigt wird.')
-        parser.add_argument('--config', nargs=1, type=str,                  help='(string) Pfad zur Configdatei (nur für run Endpunkt).');
+        parser.add_argument('--config', nargs=1, type=str,                    help='(string) Pfad zur Configdatei (nur für run Endpunkt).');
     return parser;
 
 def GetArgumentsFromCli(*cli_args: str) -> argparse.Namespace:
     parser = GetArgumentParser();
-    return parser.parse_args(cli_args);
+    args = parser.parse_args(cli_args);
+    args.checks=IsTrue(args.checks[0]);
+    args.colour=IsTrue(args.colour[0]);
+    return args;