Interface for determining package pins

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+

chipflow_lib/__init__.py

@@ -8,7 +8,10 @@
 import sys
 import tomli
 from pathlib import Path
-from pydantic import ValidationError
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from ._config_models import Config
 
 __version__ = importlib.metadata.version("chipflow_lib")
 
@@ -44,12 +47,19 @@ def _ensure_chipflow_root():
 
  if os.environ["CHIPFLOW_ROOT"] not in sys.path:
  sys.path.append(os.environ["CHIPFLOW_ROOT"])
- _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute()
- return _ensure_chipflow_root.root
+ _ensure_chipflow_root.root = Path(os.environ["CHIPFLOW_ROOT"]).absolute() #type: ignore
+ return _ensure_chipflow_root.root #type: ignore
+
+
+def _get_src_loc(src_loc_at=0):
+ frame = sys._getframe(1 + src_loc_at)
+ return (frame.f_code.co_filename, frame.f_lineno)
 
 
-def _parse_config():
+
+def _parse_config() -> 'Config':
  """Parse the chipflow.toml configuration file."""
+ from .config import _parse_config_file
  chipflow_root = _ensure_chipflow_root()
  config_file = Path(chipflow_root) / "chipflow.toml"
  try:
@@ -58,26 +68,3 @@ def _parse_config():
  raise ChipFlowError(f"Config file not found. I expected to find it at {config_file}")
  except tomli.TOMLDecodeError as e:
  raise ChipFlowError(f"TOML Error found when loading {config_file}: {e.msg} at line {e.lineno}, column {e.colno}")
-
-
-def _parse_config_file(config_file):
- """Parse a specific chipflow.toml configuration file."""
- from .config_models import Config
-
- with open(config_file, "rb") as f:
- config_dict = tomli.load(f)
-
- try:
- # Validate with Pydantic
- Config.model_validate(config_dict) # Just validate the config_dict
- return config_dict # Return the original dict for backward compatibility
- except ValidationError as e:
- # Format Pydantic validation errors in a user-friendly way
- error_messages = []
- for error in e.errors():
- location = ".".join(str(loc) for loc in error["loc"])
- message = error["msg"]
- error_messages.append(f"Error at '{location}': {message}")
-
- error_str = "\n".join(error_messages)
- raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")

chipflow_lib/_appresponse.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+from pydantic import BaseModel, PlainSerializer, model_serializer
+
+@dataclass
+class OmitIfNone:
+ pass
+
+class AppResponseModel(BaseModel):
+ @model_serializer
+ def _serialize(self):
+ skip_if_none = set()
+ serialize_aliases = dict()
+
+ # Gather fields that should omit if None
+ for name, field_info in self.model_fields.items():
+ if any(
+ isinstance(metadata, OmitIfNone) for metadata in field_info.metadata
+ ):
+ skip_if_none.add(name)
+ elif field_info.serialization_alias:
+ serialize_aliases[name] = field_info.serialization_alias
+
+ serialized = dict()
+
+ for name, value in self:
+ # Skip serializing None if it was marked with "OmitIfNone"
+ if value is None and name in skip_if_none:
+ continue
+ serialize_key = serialize_aliases.get(name, name)
+
+ # Run Annotated PlainSerializer
+ for metadata in self.model_fields[name].metadata:
+ if isinstance(metadata, PlainSerializer):
+ value = metadata.func(value)
+
+ serialized[serialize_key] = value
+
+ return serialized

chipflow_lib/_config_models.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: BSD-2-Clause
+from typing import Dict, Optional, Literal, Any, List
+
+from pydantic import BaseModel
+
+from .platforms._utils import Process, PowerConfig
+
+Voltage = float
+
+class SiliconConfig(BaseModel):
+ """Configuration for silicon in chipflow.toml."""
+ process: 'Process'
+ package: Literal["caravel", "cf20", "pga144"]
+ power: Dict[str, Voltage] = {}
+ debug: Optional[Dict[str, bool]] = None
+
+# TODO: add validation that top components, clock domains and power domains
+# not begin with '_' (unless power domain _core)
+class ChipFlowConfig(BaseModel):
+ """Root configuration for chipflow.toml."""
+ project_name: str
+ top: Dict[str, Any] = {}
+ steps: Optional[Dict[str, str]] = None
+ silicon: Optional[SiliconConfig] = None
+ clock_domains: Optional[List[str]] = None
+ power: Optional[PowerConfig] = None
+
+
+class Config(BaseModel):
+ """Root configuration model for chipflow.toml."""
+ chipflow: ChipFlowConfig

chipflow_lib/cli.py

@@ -33,14 +33,15 @@ def run(argv=sys.argv[1:]):
  commands = {}
  commands["pin"] = PinCommand(config)
 
- steps = DEFAULT_STEPS | config["chipflow"]["steps"]
- for step_name, step_reference in steps.items():
- step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
- try:
- commands[step_name] = step_cls(config)
- except Exception:
- raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
- f"using `{step_reference}`")
+ if config.chipflow.steps:
+ steps = DEFAULT_STEPS |config.chipflow.steps
+ for step_name, step_reference in steps.items():
+ step_cls = _get_cls_by_reference(step_reference, context=f"step `{step_name}`")
+ try:
+ commands[step_name] = step_cls(config)
+ except Exception:
+ raise ChipFlowError(f"Encountered error while initializing step `{step_name}` "
+ f"using `{step_reference}`")
 
  parser = argparse.ArgumentParser(
  prog="chipflow",

chipflow_lib/config.py

@@ -2,9 +2,38 @@
 import os
 
 
+import tomli
+from pydantic import ValidationError
+
+from . import ChipFlowError
+from ._config_models import Config
+
 def get_dir_models():
  return os.path.dirname(__file__) + "/models"
 
 
 def get_dir_software():
  return os.path.dirname(__file__) + "/software"
+
+
+def _parse_config_file(config_file) -> 'Config':
+ """Parse a specific chipflow.toml configuration file."""
+
+ with open(config_file, "rb") as f:
+ config_dict = tomli.load(f)
+
+ try:
+ # Validate with Pydantic
+ return Config.model_validate(config_dict) # Just validate the config_dict
+ except ValidationError as e:
+ # Format Pydantic validation errors in a user-friendly way
+ error_messages = []
+ for error in e.errors():
+ location = ".".join(str(loc) for loc in error["loc"])
+ message = error["msg"]
+ error_messages.append(f"Error at '{location}': {message}")
+
+ error_str = "\n".join(error_messages)
+ raise ChipFlowError(f"Validation error in chipflow.toml:\n{error_str}")
+
+