pyEDAA.Reports.CLI
Tools to extract data from UCDB files.
Usage
First export/convert the Aldec Coverage Database (ACDB) into UCDB (Universal Coverage Database) format. The
helper program acdb2xml (part of Active-HDL or Riviera-PRO installation) can be used.
acdb2xml -i aggregate.acdb -o ucdb.xml
At next use this layer’s service program to convert from UCDB to Cobertura format.
pyedaa-ucis export --ucdb ucdb.xml --cobertura cobertura.xml
Submodules
Functions
main(): Entrypoint to start program execution.
Classes
Application: Program class to implement the command line interface (CLI) using commands and options.
Functions
- pyEDAA.Reports.CLI.main()[source]
Entrypoint to start program execution.
- Return type:
- This function should be called either from:
if __name__ == "__main__":orconsole_scriptsentry point configured viasetuptoolsinsetup.py.
This function creates an instance of
Programin atry ... exceptenvironment. Any exception caught is formatted and printed before the program returns with a non-zero exit code.
Classes
- class pyEDAA.Reports.CLI.Application[source]
Program class to implement the command line interface (CLI) using commands and options.
Inheritance
- HeadLine: ClassVar[str] = 'Report Service Program'
Headline of the application, printed by
_PrintHeadline().
- ISSUE_TRACKER_URL: ClassVar[str] = 'https://GitHub.com/edaa-org/pyEDAA.Reports/issues'
URL to the issue tracker for reporting bugs.
- __init__()[source]
Initializer of a line-based terminal interface.
- Parameters:
mode – Optional, defines what output (normal, error, data) to write where. Default: a linear flow all to STDOUT.
- Return type:
None
- Run()[source]
Parse the command line arguments and call the handler method the command selects.
- Parameters:
enableAutoComplete – Optional, if
True, register the parser withargcomplete, if that package is installed.- Return type:
- _mainParser: ArgumentParser
The main argument parser of the application.
- _subParsers: dict[str, ArgumentParser]
Sub-command name to its argument parser.
- property BaseIndent: int
Property to access the base indentation level of written messages (
_baseIndent).The assigned level is added to every message’s own indentation.
- Returns:
Base indentation level.
- Configure(*, verbose=False, debug=False, silent=False, quiet=False, writeToStdOut=True)
Configure the verbosity of the application, usually from the command line switches.
The resulting
LogLevelis the minimum severity a message needs to be written:Severity.Debugin debug mode,Severity.Verbosein verbose mode,Severity.Silentin silent mode,Severity.Quietin quiet mode, otherwiseSeverity.Normal. Debug mode implies verbose mode.- Parameters:
verbose (
bool) – Optional, write verbose messages. Default:False.debug (
bool) – Optional, write debug messages, implying verbose messages. Default:False.silent (
bool) – Optional, reduce the messages to warnings and higher severities. Default:False.quiet (
bool) – Optional, reduce the messages to errors and always visible messages. Default:False.writeToStdOut (
bool) – Optional, write toSTDOUT. Default:True.
- Return type:
- property CriticalWarningCount: int
Read-only property to access the number of counted critical warnings.
- Returns:
Number of critical warnings.
- property Debug: bool
Check if debug messages are enabled.
- Returns:
True, if debug messages are written.
- property ErrorCount: int
Read-only property to access the number of counted errors.
- Returns:
Number of errors.
- Exit(returnCode=0)
Exit the terminal application by uninitializing color support and returning an Exit code.
- ExitOnPreviousCriticalWarnings(includeErrors=True)
Exit application if error or critical warnings have been printed.
- ExitOnPreviousWarnings(includeCriticalWarnings=True, includeErrors=True)
Exit application if error or (critical) warnings have been printed.
- FatalExit(returnCode=0)
Exit the terminal application by uninitializing color support and returning a fatal Exit code.
- Foreground: ClassVar[dict[str, str]] = {'BLUE': '\x1b[94m', 'CYAN': '\x1b[96m', 'DARK_BLUE': '\x1b[34m', 'DARK_CYAN': '\x1b[36m', 'DARK_GRAY': '\x1b[90m', 'DARK_GREEN': '\x1b[32m', 'DARK_RED': '\x1b[31m', 'DARK_YELLOW': '\x1b[33m', 'ERROR': '\x1b[91m', 'GRAY': '\x1b[37m', 'GREEN': '\x1b[92m', 'HEADLINE': '\x1b[95m', 'MAGENTA': '\x1b[95m', 'NOCOLOR': '\x1b[39m', 'RED': '\x1b[91m', 'WARNING': '\x1b[93m', 'WHITE': '\x1b[97m', 'YELLOW': '\x1b[93m'}
Terminal colors
- classmethod GetMethodsWithAttributes(predicate: Nullable[TAttributeFilter[TAttr]] = None) dict[Callable[..., Any], tuple[Attribute, ...]]
Return the class’ methods that carry at least one matching attribute.
- Parameters:
predicate (Nullable[TAttributeFilter[TAttr]]) – Optional, an attribute class, an iterable of attribute classes, or
Noneto accept every attribute.- Return type:
dict[Callable[…, Any], tuple[Attribute, …]]
- Returns:
Dictionary of methods and the matching attributes attached to them.
- Raises:
ValueError – If an element of parameter ‘predicate’ is not a sub-class of
Attribute.ValueError – If parameter ‘predicate’ is neither an attribute class nor an iterable of those.
- static GetTerminalSize()
Returns the terminal size as tuple (width, height) for Windows, macOS (Darwin), Linux, cygwin (Windows), MinGW32/64 (Windows).
- HandleUnittest(args)
Handle program calls with command
unittest.
- property Height: int
Read-only property to access the terminal’s height.
- Returns:
The terminal window’s height in characters.
- InitializeColors()
Initialize the terminal for color support by colorama.
- Return type:
- Returns:
True, if ‘colorama’ package could be imported and initialized.
- property Lines: list[Line]
Read-only property to access the list of printed lines (messages).
- Returns:
List of lines.
- property LogLevel: Severity
Property to access the minimal severity level a message needs to be written (
_writeLevel).Assigning a level replaces what
Configure()computed from the verbosity switches.- Returns:
The current minimal severity level.
- MISSING_DEPENDENCY_EXIT_CODE: ClassVar[int] = 242
Return code (242), if an optional dependency is missing. The value lives on the exception, which stays importable when this module is not - see
PrintMissingDependencyException().
- property MainParser: ArgumentParser
Read-only property to access the main argument parser (
_mainParser).- Returns:
The main argument parser.
- NOT_IMPLEMENTED_EXCEPTION_EXIT_CODE: ClassVar[int] = 240
Return code, if unimplemented methods or code sections were called.
- PrintException(ex)
Prints an exception of type
Exceptionand its traceback.If the exception as a nested action, the cause is printed as well.
If
ISSUE_TRACKER_URLis configured, a URL to the issue tracker is added.
- PrintExceptionBase(ex)
Prints an exception of type
ExceptionBaseand its traceback.If the exception as a nested action, the cause is printed as well.
If
ISSUE_TRACKER_URLis configured, a URL to the issue tracker is added.
- PrintMissingDependencyException(ex)
Print a missing optional dependency and the command lines installing it.
Unlike the other printers, this one does not report a bug: there is no traceback, and no invitation to open an issue, because nothing is wrong with the program - a package it can use is not installed. The message names the missing package and every installation option the exception carries (
InstallCommands).Attention
pyTooling.TerminalUIraises this exception itself when colorama is missing, and that happens while the module is imported - long before an application object exists, so this method cannot report that case. An application that wants to survive it catches the exception around its own imports and prints the commands directly:from pyTooling.Exceptions import MissingDependencyException try: from pyTooling.TerminalUI import TerminalApplication except MissingDependencyException as ex: print(f"{ex}
“ + ” “.join(f” {command}” for command in ex.InstallCommands))
raise SystemExit(MissingDependencyException.EXIT_CODE) from ex
- Parameters:
ex (
MissingDependencyException) –The exception to print. :returns: Never - the method exits the application with
MISSING_DEPENDENCY_EXIT_CODE.See also
PrintException()→ Print an unhandled exception and its traceback.
PrintNotImplementedError()→ Print a call to an unimplemented function or abstract method.
- Return type:
- PrintNotImplementedError(ex)
Prints a not-implemented exception of type
NotImplementedError.If
ISSUE_TRACKER_URLis configured, a URL to the issue tracker is added.- Parameters:
ex (
NotImplementedError) – The exception to print.- Return type:
- property SubParsers: dict[str, ArgumentParser]
Read-only property to access the sub-parsers (
_subParser).- Returns:
Dictionary of command names and their sub-parsers.
- TryWriteLine(line)
Check if a line object of a certain severity would be written.
- Parameters:
line – Line object to check.
- Return type:
- Returns:
True, if line would be written.
- UNHANDLED_EXCEPTION_EXIT_CODE: ClassVar[int] = 241
Return code, if an unhandled exception reached the topmost exception handler.
- UninitializeColors()
Uninitialize the terminal for color support by colorama.
- Return type:
- Returns:
True, if ‘colorama’ package could be imported and uninitialized.
- property Verbose: bool
Check if verbose messages are enabled.
- Returns:
True, if verbose messages are written.
- property WarningCount: int
Read-only property to access the number of counted warnings.
- Returns:
Number of warnings.
- property Width: int
Read-only property to access the terminal’s width.
- Returns:
The terminal window’s width in characters.
- WriteCritical(message, *, indent=0, appendLinebreak=True)
Write a critical message.
Depending on internal settings and rules, a message might be skipped.
- WriteCriticalNote(message, *, indent=0, appendLinebreak=True)
Write a critical note.
Depending on internal settings and rules, a note might be skipped.
- WriteDebug(message, *, indent=0, appendLinebreak=True)
Write a debug message.
Depending on internal settings and rules, a message might be skipped.
- WriteDryRun(message, *, indent=0, appendLinebreak=True)
Write a dry-run message message.
Depending on internal settings and rules, a message might be skipped.
- WriteError(message, *, indent=0, appendLinebreak=True)
Write an error message.
Depending on internal settings and rules, a message might be skipped.
- WriteFatal(message, *, indent=0, appendLinebreak=True, exitCode=0, immediateExit=True)
Write a fatal message and exit.
Depending on internal settings and rules, a message might be skipped.
- Parameters:
message (
str) – Message to write.indent (
int) – Optional, indentation level of the message.appendLinebreak (
bool) – Optional, append a linebreak after the message. Default:TrueexitCode (
int) – Optional, exit application with this exit code. Default:0
If0, useFATAL_EXIT_CODEas exit code.immediateExit (
bool) – Optional, exit application immediately. Default:True
- Return type:
- Returns:
True, if message was actually written.
- WriteInfo(message, *, indent=0, appendLinebreak=True)
Write an info message.
Depending on internal settings and rules, a message might be skipped.
- WriteLine(line)
Print a formatted line to the underlying terminal/console offered by the operating system.
- WriteLineToStdErr(message, end='\\n')
Low-level method for writing to
STDERR.
- WriteLineToStdOut(message, end='\\n')
Low-level method for writing to
STDOUT.
- WriteNormal(message, *, indent=0, appendLinebreak=True)
Write a normal message.
Depending on internal settings and rules, a message might be skipped.
- WriteQuiet(message, *, indent=0, appendLinebreak=True)
Write an always visible message.
This message is even visible in quiet mode.
Depending on internal settings and rules, a message might be skipped.
- WriteToStdErr(message)
Low-level method for writing to
STDERR.
- WriteToStdOut(message)
Low-level method for writing to
STDOUT.
- WriteVerbose(message, *, indent=0, appendLinebreak=True)
Write a verbose message.
Depending on internal settings and rules, a message might be skipped.
- WriteWarning(message, *, indent=0, appendLinebreak=True)
Write a warning message.
Depending on internal settings and rules, a message might be skipped.
- WriteWarningNote(message, *, indent=0, appendLinebreak=True)
Write a warning note.
Depending on internal settings and rules, a note might be skipped.
- _EnabledAutoComplete()
Register the main parser with
argcompletefor shell completion.The package is optional: when it isn’t installed, completion is silently unavailable.
- Return type:
- _GetLatestVersion(packageName, timeout=1)
Query PyPI for the latest released version of a package.
Every error - an unreachable index, a timeout, an unknown package - is answered with
None, because a version check must not fail the application it is printing the version of.
- _LOG_MESSAGE_FORMAT__: ClassVar[dict[Severity, str]] = {Severity.Debug: '{DARK_GRAY}{message}{NOCOLOR}', Severity.Verbose: '{GRAY}{message}{NOCOLOR}', Severity.DryRun: '{DARK_CYAN}[DRY] {message}{NOCOLOR}', Severity.Normal: '{WHITE}{message}{NOCOLOR}', Severity.Info: '{WHITE}{message}{NOCOLOR}', Severity.WarningNote: '{DARK_YELLOW} > {message}{NOCOLOR}', Severity.Warning: '{YELLOW}[WARNING] {message}{NOCOLOR}', Severity.CriticalNote: '{DARK_YELLOW} > {message}{NOCOLOR}', Severity.Critical: '{DARK_YELLOW}[CRITICAL] {message}{NOCOLOR}', Severity.Quiet: '{WHITE}{message}{NOCOLOR}', Severity.Error: '{RED}[ERROR] {message}{NOCOLOR}', Severity.Fatal: '{DARK_RED}[FATAL] {message}{NOCOLOR}', Severity.ExceptionNote: '{DARK_RED} > {message}{NOCOLOR}', Severity.Exception: '{RED}[EXCEPTION] {message}{NOCOLOR}'}
Message formatting rules.
- _ParseArguments()
Parse the command line arguments and route them to the selected handler method.
- Return type:
- _PrintHeadline(width=80)
Helper method to print the program headline.
Generated output
========================= centered headline =========================
- _RouteToHandler(args)
Call the handler method the parsed arguments select.
The handler is stored as an unbound function, so it is called with the application object as first parameter.
- __getstate__() dict[str, Any]
Return the object’s state for pickling, collecting every slot of the class hierarchy.
- __new__(**kwargs)
- __setstate__(state: dict[str, Any]) None
Restore the object’s state from unpickling, requiring exactly the slots of the class hierarchy.
- _stderr: TextIOWrapper
STDERR
- _stdin: TextIOWrapper
STDIN
- _stdout: TextIOWrapper
STDOUT