siliconcompiler 0.32.2__py3-none-any.whl → 0.33.0__py3-none-any.whl

siliconcompiler/utils/flowgraph.py

@@ -0,0 +1,339 @@
+import os
+import math
+from siliconcompiler import NodeStatus
+from siliconcompiler.tools._common import input_file_node_name, get_tool_task
+
+from siliconcompiler.flowgraph import RuntimeFlowgraph
+
+
+def _get_pruned_node_inputs(chip, flow, node):
+    # Ignore option from/to, we want reachable nodes of the whole flowgraph
+    flow_schema = chip.schema.get("flowgraph", flow, field="schema")
+    runtime = RuntimeFlowgraph(
+        flow_schema,
+        from_steps=set([step for step, _ in flow_schema.get_entry_nodes()]),
+        prune_nodes=chip.get('option', 'prune'))
+
+    return runtime.get_node_inputs(*node, record=chip.schema.get("record", field="schema"))
+
+
+#######################################
+def _get_flowgraph_execution_order(chip, flow, reverse=False):
+    return chip.schema.get("flowgraph", flow, field="schema").get_execution_order(reverse=reverse)
+
+
+def get_nodes_from(chip, flow, nodes):
+    runtime = RuntimeFlowgraph(
+        chip.schema.get("flowgraph", flow, field="schema"),
+        from_steps=chip.get('option', 'from'),
+        to_steps=chip.get('option', 'to'),
+        prune_nodes=chip.get('option', 'prune'))
+
+    all_nodes = set()
+    for node in nodes:
+        all_nodes.update(runtime.get_nodes_starting_at(*node))
+
+    return all_nodes
+
+
+###########################################################################
+def nodes_to_execute(chip, flow=None):
+    '''
+    Returns an ordered list of flowgraph nodes which will be executed.
+    This takes the from/to options into account if flow is the current flow or None.
+
+    Returns:
+        A list of nodes that will get executed during run() (or a specific flow).
+
+    Example:
+        >>> nodes = nodes_to_execute()
+    '''
+    if flow is None:
+        flow = chip.get('option', 'flow')
+
+    runtime = RuntimeFlowgraph(
+        chip.schema.get("flowgraph", flow, field='schema'),
+        args=(chip.get('arg', 'step'), chip.get('arg', 'index')),
+        from_steps=chip.get('option', 'from'),
+        to_steps=chip.get('option', 'to'),
+        prune_nodes=chip.get('option', 'prune'))
+
+    return runtime.get_nodes()
+
+
+###########################################################################
+def _check_flowgraph(chip, flow=None):
+    '''
+    Check if flowgraph is valid.
+
+    * Checks if all edges have valid nodes
+    * Checks that there are no duplicate edges
+    * Checks if from/to is valid
+
+    Returns True if valid, False otherwise.
+    '''
+
+    if not flow:
+        flow = chip.get('option', 'flow')
+
+    error = not chip.schema.get("flowgraph", flow, field="schema").validate(logger=chip.logger)
+    if not error:
+        error = not RuntimeFlowgraph.validate(
+            chip.schema.get("flowgraph", flow, field="schema"),
+            from_steps=chip.get('option', 'from'),
+            to_steps=chip.get('option', 'to'),
+            prune_nodes=chip.get('option', 'prune'),
+            logger=chip.logger)
+
+    return not error
+
+
+###########################################################################
+def _check_flowgraph_io(chip, nodes=None):
+    '''Check if flowgraph is valid in terms of input and output files.
+
+    Returns True if valid, False otherwise.
+    '''
+    flow = chip.get('option', 'flow')
+
+    runtime_full = RuntimeFlowgraph(
+        chip.schema.get("flowgraph", flow, field='schema'),
+        args=(chip.get('arg', 'step'), chip.get('arg', 'index')),
+        to_steps=chip.get('option', 'to'),
+        prune_nodes=chip.get('option', 'prune'))
+    runtime_flow = RuntimeFlowgraph(
+        chip.schema.get("flowgraph", flow, field='schema'),
+        args=(chip.get('arg', 'step'), chip.get('arg', 'index')),
+        from_steps=chip.get('option', 'from'),
+        to_steps=chip.get('option', 'to'),
+        prune_nodes=chip.get('option', 'prune'))
+    record = chip.schema.get("record", field='schema')
+
+    if not nodes:
+        nodes = runtime_flow.get_nodes()
+    for (step, index) in nodes:
+        # For each task, check input requirements.
+        tool, task = get_tool_task(chip, step, index, flow=flow)
+
+        if tool == 'builtin':
+            # We can skip builtins since they don't have any particular
+            # input requirements -- they just pass through what they
+            # receive.
+            continue
+
+        # Get files we receive from input nodes.
+        in_nodes = runtime_full.get_node_inputs(step, index, record=record)
+        all_inputs = set()
+        requirements = chip.get('tool', tool, 'task', task, 'input', step=step, index=index)
+        for in_step, in_index in in_nodes:
+            if (in_step, in_index) not in nodes:
+                # If we're not running the input step, the required
+                # inputs need to already be copied into the build
+                # directory.
+                workdir = chip.getworkdir(step=in_step, index=in_index)
+                in_step_out_dir = os.path.join(workdir, 'outputs')
+
+                if not os.path.isdir(in_step_out_dir):
+                    # This means this step hasn't been run, but that
+                    # will be flagged by a different check. No error
+                    # message here since it would be redundant.
+                    inputs = []
+                    continue
+
+                design = chip.get('design')
+                manifest = f'{design}.pkg.json'
+                inputs = [inp for inp in os.listdir(in_step_out_dir) if inp != manifest]
+            else:
+                inputs = _gather_outputs(chip, in_step, in_index)
+
+            for inp in inputs:
+                node_inp = input_file_node_name(inp, in_step, in_index)
+                if node_inp in requirements:
+                    inp = node_inp
+                if inp in all_inputs:
+                    chip.logger.error(f'Invalid flow: {step}{index} '
+                                      f'receives {inp} from multiple input tasks')
+                    return False
+                all_inputs.add(inp)
+
+        for requirement in requirements:
+            if requirement not in all_inputs:
+                chip.logger.error(f'Invalid flow: {step}{index} will '
+                                  f'not receive required input {requirement}.')
+                return False
+
+    return True
+
+
+###########################################################################
+def _gather_outputs(chip, step, index):
+    '''Return set of filenames that are guaranteed to be in outputs
+    directory after a successful run of step/index.'''
+
+    flow = chip.get('option', 'flow')
+    task_gather = getattr(chip._get_task_module(step, index, flow=flow, error=False),
+                          '_gather_outputs',
+                          None)
+    if task_gather:
+        return set(task_gather(chip, step, index))
+
+    tool, task = get_tool_task(chip, step, index, flow=flow)
+    return set(chip.get('tool', tool, 'task', task, 'output', step=step, index=index))
+
+
+def _get_flowgraph_information(chip, flow, io=True):
+    from siliconcompiler.scheduler import _setup_node
+    from siliconcompiler.tools._common import input_provides, input_file_node_name
+
+    # Save schema to avoid making permanent changes
+    org_schema = chip.schema
+    chip.schema = chip.schema.copy()
+
+    # Setup nodes
+    node_exec_order = _get_flowgraph_execution_order(chip, flow)
+    if io:
+        # try:
+        for layer_nodes in node_exec_order:
+            for step, index in layer_nodes:
+                _setup_node(chip, step, index, flow=flow)
+        # except:  # noqa E722
+        #     io = False
+
+    node_rank = {}
+    for rank, rank_nodes in enumerate(node_exec_order):
+        for step, index in rank_nodes:
+            node_rank[f'{step}{index}'] = rank
+
+    graph_inputs = {}
+    all_graph_inputs = set()
+    if io:
+        for step, index in chip.schema.get("flowgraph", flow, field="schema").get_nodes():
+            tool, task = get_tool_task(chip, step, index, flow=flow)
+            for keypath in chip.get('tool', tool, 'task', task, 'require', step=step, index=index):
+                key = tuple(keypath.split(','))
+                if key[0] == 'input':
+                    graph_inputs.setdefault((step, index), set()).add(keypath)
+
+        for inputs in graph_inputs.values():
+            all_graph_inputs.update(inputs)
+
+    exit_nodes = [f'{step}{index}' for step, index in chip.schema.get(
+        "flowgraph", flow, field="schema").get_exit_nodes()]
+
+    nodes = {}
+    edges = []
+
+    def clean_label(label):
+        return label.replace("<", "").replace(">", "")
+
+    def clean_text(label):
+        return label.replace("<", r"\<").replace(">", r"\>")
+
+    all_nodes = [(step, index) for step, index in sorted(
+                    chip.schema.get("flowgraph", flow, field="schema").get_nodes())
+                 if chip.get('record', 'status', step=step, index=index) != NodeStatus.SKIPPED]
+
+    runtime_flow = RuntimeFlowgraph(chip.schema.get("flowgraph", flow, field='schema'))
+    record = chip.schema.get("record", field='schema')
+
+    for step, index in all_nodes:
+        tool, task = get_tool_task(chip, step, index, flow=flow)
+
+        if io:
+            inputs = chip.get('tool', tool, 'task', task, 'input', step=step, index=index)
+            outputs = chip.get('tool', tool, 'task', task, 'output', step=step, index=index)
+            if chip.get('record', 'status', step=step, index=index) == NodeStatus.SKIPPED:
+                continue
+        else:
+            inputs = []
+            outputs = []
+
+        node = f'{step}{index}'
+        if io and (step, index) in graph_inputs:
+            inputs.extend(graph_inputs[(step, index)])
+
+        nodes[node] = {
+            "node": (step, index),
+            "file_inputs": inputs,
+            "inputs": {clean_text(f): f'input-{clean_label(f)}' for f in sorted(inputs)},
+            "outputs": {clean_text(f): f'output-{clean_label(f)}' for f in sorted(outputs)},
+            "task": f'{tool}/{task}' if tool != 'builtin' else task,
+            "is_input": node_rank[node] == 0,
+            "rank": node_rank[node]
+        }
+        nodes[node]["width"] = max(len(nodes[node]["inputs"]), len(nodes[node]["outputs"]))
+
+        if tool is None or task is None:
+            nodes[node]["task"] = None
+
+        rank_diff = {}
+        for in_step, in_index in runtime_flow.get_node_inputs(step, index, record=record):
+            rank_diff[f'{in_step}{in_index}'] = node_rank[node] - node_rank[f'{in_step}{in_index}']
+        nodes[node]["rank_diff"] = rank_diff
+
+    for step, index in all_nodes:
+        node = f'{step}{index}'
+        if io:
+            # get inputs
+            edge_stats = {}
+            for infile, in_nodes in input_provides(chip, step, index, flow=flow).items():
+                outfile = infile
+                for in_step, in_index in in_nodes:
+                    infile = outfile
+                    if infile not in nodes[node]["file_inputs"]:
+                        infile = input_file_node_name(infile, in_step, in_index)
+                        if infile not in nodes[node]["file_inputs"]:
+                            continue
+                    in_node_name = f"{in_step}{in_index}"
+                    outlabel = f"{in_node_name}:output-{clean_label(outfile)}"
+                    inlabel = f"{step}{index}:input-{clean_label(infile)}"
+
+                    if in_node_name not in edge_stats:
+                        edge_stats[in_node_name] = {
+                            "count": 0,
+                            "pairs": [],
+                            "weight": min(nodes[node]["width"], nodes[in_node_name]["width"])
+                        }
+                    edge_stats[in_node_name]["count"] += 1
+                    edge_stats[in_node_name]["pairs"].append((outlabel, inlabel))
+
+            # assign edge weights
+
+            # scale multiple weights
+            for edge_data in edge_stats.values():
+                edge_data["weight"] = int(
+                    math.floor(max(1, edge_data["weight"] / edge_data["count"])))
+
+            # lower exit nodes weights
+            if node in exit_nodes:
+                for edge_data in edge_stats.values():
+                    edge_data["weight"] = 1
+            else:
+                for edge_data in edge_stats.values():
+                    edge_data["weight"] *= 2
+
+            # adjust for rank differences, lower weight if rankdiff is greater than 1
+            for in_node, edge_data in edge_stats.items():
+                if nodes[node]["rank_diff"][in_node] > 1:
+                    edge_data["weight"] = 1
+
+            # create edges
+            for edge_data in edge_stats.values():
+                for outlabel, inlabel in edge_data["pairs"]:
+                    edges.append([outlabel, inlabel, edge_data["weight"]])
+
+            if (step, index) in graph_inputs:
+                for key in graph_inputs[(step, index)]:
+                    inlabel = f"{step}{index}:input-{clean_label(key)}"
+                    edges.append((key, inlabel, 1))
+        else:
+            all_inputs = []
+            for in_step, in_index in chip.get('flowgraph', flow, step, index, 'input'):
+                all_inputs.append(f'{in_step}{in_index}')
+            for item in all_inputs:
+                edges.append((item, node, 1 if node in exit_nodes else 2))
+
+    # Restore schema
+    chip.schema = org_schema
+
+    return all_graph_inputs, nodes, edges, io

siliconcompiler/{issue.py → utils/issue.py}

@@ -8,8 +8,9 @@ import time
 import tempfile
 from datetime import datetime
 from siliconcompiler.utils import get_file_template
-from siliconcompiler.scheduler import _makecmd, _write_task_manifest, _get_machine_info
+from siliconcompiler.scheduler import _makecmd, _write_task_manifest
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler import RecordSchema
 
 
 def generate_testcase(chip,
@@ -42,7 +43,7 @@ def generate_testcase(chip,
             sc_type = chip.get(*key, field='type')
             if 'file' not in sc_type and 'dir' not in sc_type:
                 continue
-            for _, key_step, key_index in chip.schema._getvals(*key):
+            for _, key_step, key_index in chip.schema.get(*key, field=None).getvalues():
                 chip.hash_files(*key,
                                 check=False,
                                 allow_cache=True,
@@ -224,7 +225,7 @@ def generate_testcase(chip,
     issue_information['python'] = {"path": sys.path,
                                    "version": sys.version}
     issue_information['date'] = datetime.fromtimestamp(issue_time).strftime('%Y-%m-%d %H:%M:%S')
-    issue_information['machine'] = _get_machine_info()
+    issue_information['machine'] = RecordSchema.get_machine_information()
     issue_information['run'] = {'step': step,
                                 'index': index,
                                 'libraries_included': include_libraries,
@@ -273,7 +274,9 @@ def generate_testcase(chip,
         full_archive_path = os.path.join(archive_directory, archive_name)
     full_archive_path = os.path.abspath(full_archive_path)
     # Build archive
-    arch_base_dir = os.path.basename(archive_name).split('.')[0]
+    arch_base_dir = os.path.basename(archive_name)
+    while arch_base_dir.lower().split('.')[-1] in ('gz', 'tar'):
+        arch_base_dir = '.'.join(arch_base_dir.split('.')[0:-1])
     with tarfile.open(full_archive_path, "w:gz") as tar:
         # Add individual files
         add_files = [manifest_path,

siliconcompiler/utils/logging.py

@@ -1,34 +1,77 @@
 import logging
 import sys
+from siliconcompiler.remote import client
+from siliconcompiler import utils
 
 
-class LoggerFormatter(logging.Formatter):
-    def __init__(self, log_formatprefix, level_fmt, message_fmt):
-        self.__formats = {}
+class SCBlankLoggerFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__("%(message)s")
 
-        self.add_format(None, log_formatprefix + level_fmt, message_fmt)
-        for level in [logging.DEBUG,
-                      logging.INFO,
-                      logging.WARNING,
-                      logging.ERROR,
-                      logging.CRITICAL]:
-            self.add_format(level, log_formatprefix + level_fmt, message_fmt)
 
-    def format(self, record):
-        log_fmt = self.__formats.get(record.levelno)
-        if not log_fmt:
-            log_fmt = self.__formats.get(None)
-        formatter = logging.Formatter(log_fmt)
-        return formatter.format(record)
+class SCDebugLoggerFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__(
+            "| %(levelname)-8s | %(filename)-20s : %(funcName)-10s | %(lineno)-4s | %(message)s")
+
+
+class SCDebugInRunLoggerFormatter(logging.Formatter):
+    def __init__(self, chip, jobname, step, index):
+        super().__init__(
+            SCInRunLoggerFormatter.configureFormat(
+                "| %(levelname)-8s | %(filename)-20s : %(funcName)-10s | %(lineno)-4s |"
+                " {} | {} | {} | %(message)s",
+                chip, step, index))
+
+
+class SCLoggerFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__("| %(levelname)-8s | %(message)s")
+
+
+class SCInRunLoggerFormatter(logging.Formatter):
+    def __init__(self, chip, jobname, step, index):
+        super().__init__(
+            SCInRunLoggerFormatter.configureFormat(
+                "| %(levelname)-8s | {} | {} | {} | %(message)s",
+                chip, step, index))
+
+    @staticmethod
+    def configureFormat(fmt, chip, step, index):
+        max_width = 20
 
-    def add_format(self, level, level_format, message_format):
-        if level == logging.CRITICAL:
-            self.__formats[level] = level_format + message_format
+        flow = chip.get('option', 'flow')
+        if flow:
+            nodes_to_run = list(chip.schema.get("flowgraph", flow, field="schema").get_nodes())
         else:
-            self.__formats[level] = level_format + " " + message_format
+            nodes_to_run = []
 
+        # Figure out how wide to make step and index fields
+        max_step_len = 1
+        max_index_len = 1
 
-class ColorStreamFormatter(LoggerFormatter):
+        if chip.get('option', 'remote'):
+            nodes_to_run.append((client.remote_step_name, '0'))
+        for future_step, future_index in nodes_to_run:
+            max_step_len = max(len(future_step), max_step_len)
+            max_index_len = max(len(future_index), max_index_len)
+        max_step_len = min(max_step_len, max_width)
+        max_index_len = min(max_index_len, max_width)
+
+        jobname = chip.get('option', 'jobname')
+
+        if step is None:
+            step = '-' * max(max_step_len // 4, 1)
+        if index is None:
+            index = '-' * max(max_index_len // 4, 1)
+
+        return fmt.format(
+            utils.truncate_text(jobname, max_width),
+            f'{utils.truncate_text(step, max_step_len): <{max_step_len}}',
+            f'{utils.truncate_text(index, max_step_len): >{max_index_len}}')
+
+
+class SCColorLoggerFormatter(logging.Formatter):
     '''
     Apply color to stream logger
     '''
@@ -38,20 +81,30 @@ class ColorStreamFormatter(LoggerFormatter):
     bold_red = u"\u001b[31;1m"
     reset = u"\u001b[0m"
 
-    def __init__(self, log_formatprefix, level_fmt, message_fmt):
-        super().__init__(log_formatprefix, level_fmt, message_fmt)
+    def __init__(self, root_formatter):
+        super().__init__()
 
-        # Replace with colors
-        for level, color in [(logging.DEBUG, ColorStreamFormatter.blue),
-                             (logging.WARNING, ColorStreamFormatter.yellow),
-                             (logging.ERROR, ColorStreamFormatter.red),
-                             (logging.CRITICAL, ColorStreamFormatter.bold_red)]:
-            if color:
-                fmt = log_formatprefix + color + level_fmt + ColorStreamFormatter.reset
-            else:
-                fmt = log_formatprefix + level_fmt
+        self.__create_color_format(root_formatter._style._fmt)
+
+    def __create_color_format(self, fmt):
+        self.__formatters = {
+            None: logging.Formatter(fmt)
+        }
+
+        for level, color in [(logging.DEBUG, SCColorLoggerFormatter.blue),
+                             (logging.WARNING, SCColorLoggerFormatter.yellow),
+                             (logging.ERROR, SCColorLoggerFormatter.red),
+                             (logging.CRITICAL, SCColorLoggerFormatter.bold_red)]:
+            self.__formatters[level] = logging.Formatter(
+                fmt.replace('%(levelname)-8s',
+                            color + '%(levelname)-8s' + SCColorLoggerFormatter.reset))
+
+    def format(self, record):
+        log_fmt = self.__formatters.get(record.levelno)
+        if not log_fmt:
+            log_fmt = self.__formatters.get(None)
 
-            self.add_format(level, fmt, message_fmt)
+        return log_fmt.format(record)
 
     @staticmethod
     def supports_color(handler):

{siliconcompiler-0.32.2.dist-info → siliconcompiler-0.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siliconcompiler
-Version: 0.32.2
+Version: 0.33.0
 Summary: A compiler framework that automates translation from source code to silicon.
 Author-email: Andreas Olofsson <andreas.d.olofsson@gmail.com>
 License: Apache License 2.0
@@ -26,7 +26,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp==3.10.11; python_version <= "3.8"
-Requires-Dist: aiohttp==3.11.14; python_version >= "3.9"
+Requires-Dist: aiohttp<3.12.0,>=3.10.11; python_version >= "3.9"
 Requires-Dist: requests==2.32.3
 Requires-Dist: PyYAML==6.0.2
 Requires-Dist: pandas>=1.1.5
@@ -36,7 +36,7 @@ Requires-Dist: distro==1.9.0
 Requires-Dist: packaging<25,>=21.3
 Requires-Dist: psutil>=5.8.0
 Requires-Dist: Pillow==10.4.0; python_version <= "3.8"
-Requires-Dist: Pillow==11.1.0; python_version >= "3.9"
+Requires-Dist: Pillow==11.2.1; python_version >= "3.9"
 Requires-Dist: GitPython==3.1.44
 Requires-Dist: lambdapdk>=0.1.47
 Requires-Dist: PyGithub==2.6.1
@@ -46,22 +46,24 @@ Requires-Dist: fastjsonschema==2.21.1
 Requires-Dist: docker==7.1.0
 Requires-Dist: importlib_metadata; python_version < "3.10"
 Requires-Dist: orjson==3.10.15; python_version <= "3.8"
-Requires-Dist: orjson==3.10.16; python_version >= "3.9"
+Requires-Dist: orjson==3.10.18; python_version >= "3.9"
 Requires-Dist: pyslang==8.0.0
 Requires-Dist: streamlit==1.40.1; python_version <= "3.8"
-Requires-Dist: streamlit==1.44.0; python_version >= "3.9" and python_full_version != "3.9.7"
+Requires-Dist: streamlit==1.45.0; python_version >= "3.9" and python_full_version != "3.9.7"
 Requires-Dist: streamlit_agraph==0.0.45; python_full_version != "3.9.7"
 Requires-Dist: streamlit-antd-components==0.3.2; python_full_version != "3.9.7"
 Requires-Dist: streamlit_javascript==0.1.5; python_full_version != "3.9.7"
 Requires-Dist: streamlit-autorefresh==1.0.1; python_full_version != "3.9.7"
+Requires-Dist: rich==13.9.4; python_version <= "3.8"
+Requires-Dist: rich<15.0.0,>=14.0.0; python_version >= "3.9"
 Provides-Extra: test
 Requires-Dist: pytest==8.3.5; extra == "test"
 Requires-Dist: pytest-xdist==3.6.1; extra == "test"
-Requires-Dist: pytest-timeout==2.3.1; extra == "test"
+Requires-Dist: pytest-timeout==2.4.0; extra == "test"
 Requires-Dist: pytest-asyncio==0.24.0; python_version <= "3.8" and extra == "test"
 Requires-Dist: pytest-asyncio==0.26.0; python_version >= "3.9" and extra == "test"
 Requires-Dist: pytest-cov==5.0.0; python_version <= "3.8" and extra == "test"
-Requires-Dist: pytest-cov==6.0.0; python_version >= "3.9" and extra == "test"
+Requires-Dist: pytest-cov==6.1.1; python_version >= "3.9" and extra == "test"
 Requires-Dist: responses==0.25.7; extra == "test"
 Requires-Dist: PyVirtualDisplay==3.0; extra == "test"
 Requires-Dist: logiklib==0.1.0; extra == "test"
@@ -75,7 +77,7 @@ Requires-Dist: pip-licenses==5.0.0; extra == "docs"
 Requires-Dist: pydata-sphinx-theme==0.16.1; extra == "docs"
 Requires-Dist: sc-leflib>=0.2.0; extra == "docs"
 Provides-Extra: profile
-Requires-Dist: gprof2dot==2024.6.6; extra == "profile"
+Requires-Dist: gprof2dot==2025.4.14; extra == "profile"
 Provides-Extra: optimizer
 Requires-Dist: google-vizier[jax]==0.1.21; python_version >= "3.10" and extra == "optimizer"
 Dynamic: license-file