siliconcompiler 0.35.0__py3-none-any.whl → 0.35.1__py3-none-any.whl

siliconcompiler/scheduler/taskscheduler.py

@@ -1,9 +1,12 @@
+import logging
 import multiprocessing
 import sys
 import time
 
 import os.path
 
+from typing import List, Dict, Tuple, Optional, Callable, ClassVar, Any, Literal, TYPE_CHECKING
+
 from logging.handlers import QueueListener
 
 from siliconcompiler import NodeStatus
@@ -17,6 +20,12 @@ from siliconcompiler.utils.logging import SCBlankLoggerFormatter, SCBlankColorle
 from siliconcompiler.utils.multiprocessing import MPManager
 from siliconcompiler.scheduler import SCRuntimeError
 
+if TYPE_CHECKING:
+    from siliconcompiler import Flowgraph
+    from siliconcompiler.project import Project
+    from siliconcompiler.scheduler import SchedulerNode
+    from siliconcompiler.schema_support.record import RecordSchema
+
 
 class TaskScheduler:
     """A class for managing the execution of individual tasks in a flowgraph.
@@ -26,7 +35,7 @@ class TaskScheduler:
     dependency checking. It operates on a set of pending tasks defined by the
     main Scheduler and executes them in a loop until the flow is complete.
     """
-    __callbacks = {
+    __callbacks: ClassVar[Dict[str, Callable[..., None]]] = {
         "pre_run": lambda project: None,
         "pre_node": lambda project, step, index: None,
         "post_node": lambda project, step, index: None,
@@ -34,7 +43,8 @@ class TaskScheduler:
     }
 
     @staticmethod
-    def register_callback(hook, func):
+    def register_callback(hook: Literal["pre_run", "pre_node", "post_node", "post_run"],
+                          func: Callable[..., None]) -> None:
         """Registers a callback function to be executed at a specific hook point.
 
         Valid hooks are 'pre_run', 'pre_node', 'post_node', and 'post_run'.
@@ -51,7 +61,7 @@ class TaskScheduler:
             raise ValueError(f"{hook} is not a valid callback")
         TaskScheduler.__callbacks[hook] = func
 
-    def __init__(self, project, tasks):
+    def __init__(self, project: "Project", tasks: Dict[Tuple[str, str], "SchedulerNode"]):
         """Initializes the TaskScheduler.
 
         Args:
@@ -63,14 +73,15 @@ class TaskScheduler:
         self.__logger = self.__project.logger
         self.__logger_console_handler = self.__project._logger_console
         self.__schema = self.__project
-        self.__flow = self.__schema.get("flowgraph", self.__project.get('option', 'flow'),
-                                        field="schema")
-        self.__record = self.__schema.get("record", field="schema")
+        self.__flow: "Flowgraph" = self.__schema.get("flowgraph",
+                                                     self.__project.get('option', 'flow'),
+                                                     field="schema")
+        self.__record: "RecordSchema" = self.__schema.get("record", field="schema")
         self.__dashboard = project._Project__dashboard
 
         self.__max_cores = utils.get_cores()
         self.__max_threads = utils.get_cores()
-        self.__max_parallel_run = self.__project.get('option', 'scheduler', 'maxnodes')
+        self.__max_parallel_run = self.__project.option.scheduler.get_maxnodes()
         if not self.__max_parallel_run:
             self.__max_parallel_run = utils.get_cores()
         # clip max parallel jobs to 1 <= jobs <= max_cores
@@ -78,19 +89,19 @@ class TaskScheduler:
 
         self.__runtime_flow = RuntimeFlowgraph(
             self.__flow,
-            from_steps=self.__project.get('option', 'from'),
-            to_steps=self.__project.get('option', 'to'),
-            prune_nodes=self.__project.get('option', 'prune'))
+            from_steps=self.__project.option.get_from(),
+            to_steps=self.__project.option.get_to(),
+            prune_nodes=self.__project.option.get_prune())
 
         self.__log_queue = MPManager.get_manager().Queue()
 
-        self.__nodes = {}
-        self.__startTimes = {}
-        self.__dwellTime = 0.1
+        self.__nodes: Dict[Tuple[str, str], Dict[str, Any]] = {}
+        self.__startTimes: Dict[Optional[Tuple[str, str]], float] = {}
+        self.__dwellTime: float = 0.1
 
         self.__create_nodes(tasks)
 
-    def __create_nodes(self, tasks):
+    def __create_nodes(self, tasks: Dict[Tuple[str, str], "SchedulerNode"]) -> None:
         """
         Private helper to prepare all pending tasks for execution.
 
@@ -104,7 +115,7 @@ class TaskScheduler:
         runtime = RuntimeFlowgraph(
             self.__flow,
             from_steps=set([step for step, _ in self.__flow.get_entry_nodes()]),
-            prune_nodes=self.__project.get('option', 'prune'))
+            prune_nodes=self.__project.option.get_prune())
 
         init_funcs = set()
 
@@ -137,11 +148,18 @@ class TaskScheduler:
             init_funcs.add(task["node"].init)
             self.__nodes[(step, index)] = task
 
+        # Create ordered list of nodes
+        self.__ordered_nodes: List[Tuple[str, str]] = []
+        for levelnodes in self.__runtime_flow.get_execution_order():
+            for node in levelnodes:
+                if node in self.__nodes:
+                    self.__ordered_nodes.append(node)
+
         # Call preprocessing for schedulers
         for init_func in init_funcs:
             init_func(self.__project)
 
-    def run(self, job_log_handler):
+    def run(self, job_log_handler: logging.Handler) -> None:
         """
         The main entry point for the task scheduling loop.
 
@@ -190,7 +208,7 @@ class TaskScheduler:
             job_log_handler.setFormatter(file_formatter)
             self.__logger.addHandler(job_log_handler)
 
-    def __run_loop(self):
+    def __run_loop(self) -> None:
         """
         The core execution loop of the scheduler.
 
@@ -223,39 +241,41 @@ class TaskScheduler:
                 # if there are more than 1, join the first with a timeout
                 self.__nodes[running_nodes[0]]["proc"].join(timeout=self.__dwellTime)
 
-    def get_nodes(self):
-        """Gets a sorted list of all nodes managed by this scheduler.
+    def get_nodes(self) -> List[Tuple[str, str]]:
+        """Gets an ordered list of all nodes managed by this scheduler.
 
         Returns:
             list: A list of (step, index) tuples for all nodes.
         """
-        return sorted(self.__nodes.keys())
+        return self.__ordered_nodes
 
-    def get_running_nodes(self):
-        """Gets a sorted list of all nodes that are currently running.
+    def get_running_nodes(self) -> List[Tuple[str, str]]:
+        """Gets an ordered list of all nodes that are currently running.
 
         Returns:
             list: A list of (step, index) tuples for running nodes.
         """
         nodes = []
-        for node, info in self.__nodes.items():
+        for node in self.get_nodes():
+            info = self.__nodes[node]
             if info["running"]:
                 nodes.append(node)
-        return sorted(nodes)
+        return nodes
 
-    def get_nodes_waiting_to_run(self):
-        """Gets a sorted list of all nodes that are pending execution.
+    def get_nodes_waiting_to_run(self) -> List[Tuple[str, str]]:
+        """Gets an ordered list of all nodes that are pending execution.
 
         Returns:
             list: A list of (step, index) tuples for pending nodes.
         """
         nodes = []
-        for node, info in self.__nodes.items():
+        for node in self.get_nodes():
+            info = self.__nodes[node]
             if not info["running"] and info["proc"]:
                 nodes.append(node)
-        return sorted(nodes)
+        return nodes
 
-    def __process_completed_nodes(self):
+    def __process_completed_nodes(self) -> bool:
         """
         Private helper to check for and process completed nodes.
 
@@ -310,7 +330,7 @@ class TaskScheduler:
 
         return changed
 
-    def __allow_start(self, node):
+    def __allow_start(self, node: Tuple[str, str]) -> bool:
         """
         Private helper to check if a node is allowed to start based on resources.
 
@@ -344,7 +364,7 @@ class TaskScheduler:
         # allow
         return True
 
-    def __launch_nodes(self):
+    def __launch_nodes(self) -> bool:
         """
         Private helper to launch new nodes whose dependencies are met.
 
@@ -405,7 +425,7 @@ class TaskScheduler:
 
         return changed
 
-    def check(self):
+    def check(self) -> None:
         """
         Checks if the flow completed successfully.
 

siliconcompiler/schema/baseschema.py

@@ -25,7 +25,7 @@ except ModuleNotFoundError:
 import os.path
 
 from functools import cache
-from typing import Dict, Type, Tuple, Union, Set, Callable, List
+from typing import Dict, Type, Tuple, Union, Set, Callable, List, Optional, TextIO, Iterable
 
 from .parameter import Parameter, NodeValue
 from .journal import Journal
@@ -50,7 +50,7 @@ class BaseSchema:
         self.__key = None
 
     @property
-    def _keypath(self):
+    def _keypath(self) -> Tuple[str, ...]:
         '''
         Returns the key to the current section of the schema
         '''
@@ -103,7 +103,7 @@ class BaseSchema:
 
     @staticmethod
     @cache
-    def __load_schema_class(cls_name: str) -> Type["BaseSchema"]:
+    def __load_schema_class(cls_name: str) -> Optional[Type["BaseSchema"]]:
         """
         Load a schema class from a string
         """
@@ -125,7 +125,7 @@ class BaseSchema:
         return cls
 
     @staticmethod
-    def __process_meta_section(meta: Dict[str, str]) -> Type["BaseSchema"]:
+    def __process_meta_section(meta: Dict[str, str]) -> Optional[Type["BaseSchema"]]:
         """
         Handle __meta__ section of the schema by loading the appropriate class
         """
@@ -143,21 +143,24 @@ class BaseSchema:
         return cls
 
     @staticmethod
-    def __extractversion(manifest: Dict):
+    def __extractversion(manifest: Dict) -> Optional[Tuple[int, ...]]:
         schema_version = manifest.get(BaseSchema._version_key, None)
         if schema_version:
             param = Parameter.from_dict(schema_version, [BaseSchema._version_key], None)
             return tuple([int(v) for v in param.get().split('.')])
         return None
 
-    def _from_dict(self, manifest: Dict, keypath: Tuple[str], version: str = None):
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         '''
         Decodes a dictionary into a schema object
 
         Args:
             manifest (dict): Manifest to decide.
             keypath (list of str): Path to the current keypath.
-            version (packaging.Version): Version of the dictionary schema
+            version ((int, int, int)): Version of the dictionary schema
         '''
         # find schema version
         if not version:
@@ -180,7 +183,7 @@ class BaseSchema:
             data = manifest.get("default", None)
             if data:
                 del manifest["default"]
-                self.__default._from_dict(data, keypath + ["default"], version=version)
+                self.__default._from_dict(data, list(keypath) + ["default"], version=version)
                 handled.add("default")
 
         for key, data in manifest.items():
@@ -190,7 +193,7 @@ class BaseSchema:
                 cls = BaseSchema.__process_meta_section(data["__meta__"])
                 if cls is BaseSchema and self.__default:
                     # Use default when BaseSchema is the class
-                    obj = self.__default.copy(key=keypath + [key])
+                    obj = self.__default.copy(key=list(keypath) + [key])
                     self.__manifest[key] = obj
                 elif cls:
                     # Create object and connect to schema
@@ -201,11 +204,11 @@ class BaseSchema:
 
             # Use default if it is available
             if not obj and self.__default:
-                obj = self.__default.copy(key=keypath + [key])
+                obj = self.__default.copy(key=list(keypath) + [key])
                 self.__manifest[key] = obj
 
             if obj:
-                obj._from_dict(data, keypath + [key], version=version)
+                obj._from_dict(data, list(keypath) + [key], version=version)
                 handled.add(key)
             else:
                 missing.add(key)
@@ -214,7 +217,9 @@ class BaseSchema:
 
     # Manifest methods
     @classmethod
-    def from_manifest(cls, filepath: str = None, cfg: Dict = None) -> "BaseSchema":
+    def from_manifest(cls,
+                      filepath: Union[None, str] = None,
+                      cfg: Union[None, Dict] = None) -> "BaseSchema":
         '''
         Create a new schema based on the provided source files.
 
@@ -240,12 +245,12 @@ class BaseSchema:
         else:
             schema = cls()
 
-        schema._from_dict(cfg, [])
+        schema._from_dict(cfg, tuple())
 
         return schema
 
     @staticmethod
-    def __open_file(filepath: str, is_read: bool = True):
+    def __open_file(filepath: str, is_read: bool = True) -> TextIO:
         _, ext = os.path.splitext(filepath)
         if ext.lower() == ".gz":
             if not _has_gzip:
@@ -257,7 +262,7 @@ class BaseSchema:
         return f"[{','.join([*self._keypath, *key])}]"
 
     @staticmethod
-    def _read_manifest(filepath: str):
+    def _read_manifest(filepath: str) -> Dict:
         """
         Reads a manifest from disk and returns dictionary.
 
@@ -273,7 +278,7 @@ class BaseSchema:
 
         return manifest
 
-    def read_manifest(self, filepath: str):
+    def read_manifest(self, filepath: str) -> None:
         """
         Reads a manifest from disk and replaces the current data with the data in the file.
 
@@ -287,7 +292,7 @@ class BaseSchema:
 
         self._from_dict(BaseSchema._read_manifest(filepath), [])
 
-    def write_manifest(self, filepath: str):
+    def write_manifest(self, filepath: str) -> None:
         '''
         Writes the manifest to a file.
 
@@ -301,13 +306,14 @@ class BaseSchema:
 
         fout = BaseSchema.__open_file(filepath, is_read=False)
 
-        if _has_orjson:
-            manifest_str = json.dumps(self.getdict(), option=json.OPT_INDENT_2).decode()
-        else:
-            manifest_str = json.dumps(self.getdict(), indent=2)
-        fout.write(manifest_str)
-
-        fout.close()
+        try:
+            if _has_orjson:
+                manifest_str = json.dumps(self.getdict(), option=json.OPT_INDENT_2).decode()
+            else:
+                manifest_str = json.dumps(self.getdict(), indent=2)
+            fout.write(manifest_str)
+        finally:
+            fout.close()
 
     # Accessor methods
     def __search(self,
@@ -315,7 +321,7 @@ class BaseSchema:
                  insert_defaults: bool = False,
                  use_default: bool = False,
                  require_leaf: bool = True,
-                 complete_path: bool = None) -> Union["BaseSchema", Parameter]:
+                 complete_path: Optional[List[str]] = None) -> Union["BaseSchema", Parameter]:
         if len(keypath) == 0:
             if require_leaf:
                 raise KeyError
@@ -356,8 +362,8 @@ class BaseSchema:
             raise KeyError
         return key_param
 
-    def get(self, *keypath: str, field: str = 'value',
-            step: str = None, index: Union[int, str] = None):
+    def get(self, *keypath: str, field: Optional[str] = 'value',
+            step: Optional[str] = None, index: Optional[Union[int, str]] = None):
         """
         Returns a parameter field from the schema.
 
@@ -413,8 +419,9 @@ class BaseSchema:
             e.args = (new_msg, *e.args[1:])
             raise e
 
-    def set(self, *args: str, field: str = 'value', clobber: bool = True,
-            step: str = None, index: Union[int, str] = None):
+    def set(self, *args, field: str = 'value', clobber: bool = True,
+            step: Optional[str] = None, index: Optional[Union[int, str]] = None) \
+            -> Optional[Union[List[NodeValue], NodeValue]]:
         '''
         Sets a schema parameter field.
 
@@ -442,7 +449,7 @@ class BaseSchema:
         *keypath, value = args
 
         try:
-            param = self.__search(*keypath, insert_defaults=True)
+            param: Parameter = self.__search(*keypath, insert_defaults=True)
         except KeyError:
             raise KeyError(f"{self.__format_key(*keypath)} is not a valid keypath")
 
@@ -459,8 +466,9 @@ class BaseSchema:
             e.args = (new_msg, *e.args[1:])
             raise e
 
-    def add(self, *args: str, field: str = 'value',
-            step: str = None, index: Union[int, str] = None):
+    def add(self, *args, field: str = 'value',
+            step: Optional[str] = None, index: Optional[Union[int, str]] = None) \
+            -> Optional[Union[List[NodeValue], NodeValue]]:
         '''
         Adds item(s) to a schema parameter list.
 
@@ -487,7 +495,7 @@ class BaseSchema:
         *keypath, value = args
 
         try:
-            param = self.__search(*keypath, insert_defaults=True)
+            param: Parameter = self.__search(*keypath, insert_defaults=True)
         except KeyError:
             raise KeyError(f"{self.__format_key(*keypath)} is not a valid keypath")
 
@@ -503,7 +511,9 @@ class BaseSchema:
             e.args = (new_msg, *e.args[1:])
             raise e
 
-    def unset(self, *keypath: str, step: str = None, index: Union[int, str] = None):
+    def unset(self, *keypath: str,
+              step: Optional[str] = None,
+              index: Optional[Union[int, str]] = None) -> None:
         '''
         Unsets a schema parameter.
 
@@ -610,7 +620,7 @@ class BaseSchema:
             return isinstance(param, Parameter)
         return True
 
-    def getkeys(self, *keypath: str) -> Tuple[str]:
+    def getkeys(self, *keypath: str) -> Tuple[str, ...]:
         """
         Returns a tuple of schema dictionary keys.
 
@@ -640,7 +650,7 @@ class BaseSchema:
 
         return tuple(sorted(key_param.__manifest.keys()))
 
-    def allkeys(self, *keypath: str, include_default: bool = True) -> Set[Tuple[str]]:
+    def allkeys(self, *keypath: str, include_default: bool = True) -> Set[Tuple[str, ...]]:
         '''
         Returns all keypaths in the schema as a set of tuples.
 
@@ -677,7 +687,7 @@ class BaseSchema:
 
         return "BaseSchema"
 
-    def _getdict_meta(self) -> Dict[str, str]:
+    def _getdict_meta(self) -> Dict[str, Optional[Union[str, int, float]]]:
         """
         Returns the meta data for getdict
         """
@@ -746,7 +756,7 @@ class BaseSchema:
         return manifest
 
     # Utility functions
-    def copy(self, key: Tuple[str] = None):
+    def copy(self, key: Optional[Tuple[str, ...]] = None) -> "BaseSchema":
         """
         Returns a copy of this schema.
 
@@ -769,20 +779,22 @@ class BaseSchema:
 
         return schema_copy
 
-    def _find_files_search_paths(self, keypath: Tuple[str], step: str, index: str):
+    def _find_files_search_paths(self, key: str,
+                                 step: Optional[str],
+                                 index: Optional[Union[int, str]]) -> List[str]:
         """
         Returns a list of paths to search during find files.
 
         Args:
-            keypath (str): final component of keypath
+            key (str): final component of keypath
             step (str): Step name.
             index (str): Index name.
         """
         return []
 
-    def _find_files_dataroot_resolvers(self):
+    def _find_files_dataroot_resolvers(self) -> Dict[str, Union[str, Callable]]:
         """
-        Returns a dictionary of path resolevrs data directory handling for find_files
+        Returns a dictionary of path resolvers data directory handling for find_files
 
         Returns:
             dictionary of str to resolver mapping
@@ -792,10 +804,11 @@ class BaseSchema:
         return self.__parent._find_files_dataroot_resolvers()
 
     def _find_files(self, *keypath: str, missing_ok: bool = False,
-                    step: str = None, index: Union[int, str] = None,
-                    dataroots: Dict[str, Union[str, Callable]] = None,
-                    collection_dir: str = None,
-                    cwd: str = None) -> Union[str, List[str], Set[str]]:
+                    step: Optional[str] = None, index: Optional[Union[int, str]] = None,
+                    dataroots: Optional[Dict[str, Union[str, Callable]]] = None,
+                    collection_dir: Optional[str] = None,
+                    cwd: Optional[str] = None) \
+            -> Union[Optional[str], List[Optional[str]], Set[Optional[str]]]:
         """
         Returns absolute paths to files or directories based on the keypath
         provided.
@@ -836,11 +849,12 @@ class BaseSchema:
             cwd=cwd, hash=False)
 
     def __find_files_or_hash(self, *keypath: str, missing_ok: bool = False,
-                             step: str = None, index: Union[int, str] = None,
-                             dataroots: Dict[str, Union[str, Callable]] = None,
-                             collection_dir: str = None,
-                             cwd: str = None,
-                             hash: bool = False) -> Union[str, List[str], Set[str]]:
+                             step: Optional[str] = None, index: Optional[Union[int, str]] = None,
+                             dataroots: Optional[Dict[str, Union[str, Callable]]] = None,
+                             collection_dir: Optional[str] = None,
+                             cwd: Optional[str] = None,
+                             hash: bool = False) \
+            -> Union[Optional[str], List[Optional[str]], Set[Optional[str]]]:
         """
         Returns absolute paths to files or directories based on the keypath
         provided.
@@ -875,14 +889,15 @@ class BaseSchema:
             the schema.
         """
 
-        base_schema = self.get(*keypath[0:-1], field="schema")
+        base_schema: BaseSchema = self.get(*keypath[0:-1], field="schema")
 
-        param = base_schema.get(keypath[-1], field=None)
-        paramtype = param.get(field='type')
+        param: Parameter = base_schema.get(keypath[-1], field=None)
+        paramtype: str = param.get(field='type')
         if 'file' not in paramtype and 'dir' not in paramtype:
             raise TypeError(
                 f'Cannot find files on {self.__format_key(*keypath)}, must be a path type')
 
+        hashalgo: Optional[str] = None
         if hash:
             hashalgo = param.get(field="hashalgo")
 
@@ -911,7 +926,7 @@ class BaseSchema:
         for path in paths:
             search_paths = root_search_paths.copy()
 
-            dataroot = path.get(field="dataroot")
+            dataroot: Optional[str] = path.get(field="dataroot")
             if dataroot:
                 if dataroot not in dataroots:
                     raise ValueError(f"Resolver for {dataroot} not provided: "
@@ -956,11 +971,11 @@ class BaseSchema:
             return resolved_paths[0]
         return resolved_paths
 
-    def _check_filepaths(self, ignore_keys: bool = None,
-                         logger: logging.Logger = None,
-                         dataroots: Dict[str, Union[str, Callable]] = None,
-                         collection_dir: str = None,
-                         cwd: str = None) -> bool:
+    def _check_filepaths(self, ignore_keys: Optional[Iterable[Tuple[str, ...]]] = None,
+                         logger: Optional[logging.Logger] = None,
+                         dataroots: Optional[Dict[str, Union[str, Callable]]] = None,
+                         collection_dir: Optional[str] = None,
+                         cwd: Optional[str] = None) -> bool:
         '''
         Verifies that paths to all files in manifest are valid.
 
@@ -990,8 +1005,8 @@ class BaseSchema:
             if keypath in ignore_keys:
                 continue
 
-            param = self.get(*keypath, field=None)
-            paramtype = param.get(field='type')
+            param: Parameter = self.get(*keypath, field=None)
+            paramtype: str = param.get(field='type')
 
             if 'file' not in paramtype and 'dir' not in paramtype:
                 continue
@@ -1026,10 +1041,10 @@ class BaseSchema:
         return not error
 
     def _hash_files(self, *keypath, missing_ok: bool = False,
-                    step: str = None, index: Union[int, str] = None,
-                    dataroots: Dict[str, Union[str, Callable]] = None,
-                    collection_dir: str = None,
-                    cwd: str = None):
+                    step: Optional[str] = None, index: Optional[Union[int, str]] = None,
+                    dataroots: Optional[Dict[str, Union[str, Callable]]] = None,
+                    collection_dir: Optional[str] = None,
+                    cwd: Optional[str] = None):
         '''Generates hash values for a list of parameter files.
 
         Generates a hash value for each file found in the keypath. If existing
@@ -1144,7 +1159,11 @@ class BaseSchema:
 
         return self.__active.get(field, defvalue)
 
-    def __process_active(self, param, nodevalues):
+    def __process_active(self, param: Parameter,
+                         nodevalues: Optional[Union[List[NodeValue],
+                                                    Set[NodeValue],
+                                                    Tuple[NodeValue, ...],
+                                                    NodeValue]]) -> None:
         if not self.__active:
             return
 
@@ -1173,14 +1192,14 @@ class BaseSchema:
 
     def _generate_doc(self, doc,
                       ref_root: str = "",
-                      key_offset: Tuple[str] = None,
+                      key_offset: Optional[Tuple[str, ...]] = None,
                       detailed: bool = True):
         from .docs.utils import build_section_with_target, build_schema_value_table, get_key_ref, \
             parse_rst
         from docutils import nodes
 
         if not key_offset:
-            key_offset = []
+            key_offset = tuple()
 
         if detailed:
             sections = []

siliconcompiler/schema/docs/schemagen.py

@@ -136,9 +136,10 @@ class SchemaGen(SphinxDirective):
                         methods_sec += cls_ref
                     schema_sec += methods_sec
 
-            key_offset = [key_part
-                          for key_part in self.options.get("key_offset", "").split(",")
-                          if key_part]
+            key_offset = tuple(
+                [key_part
+                 for key_part in self.options.get("key_offset", "").split(",")
+                 if key_part])
             if not key_offset:
                 key_offset = None