From 3380048dbb248255d7ce9f4ebf9819b8739e6b3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Fran=C3=A7ois=20Nguyen?= Date: Tue, 7 May 2024 05:08:38 +0200 Subject: [PATCH] Replace .format() with f-strings in error messages. --- amaranth_soc/event.py | 6 +-- amaranth_soc/memory.py | 96 ++++++++++++++++++------------------------ amaranth_soc/periph.py | 38 +++++++---------- 3 files changed, 58 insertions(+), 82 deletions(-) diff --git a/amaranth_soc/event.py b/amaranth_soc/event.py index 106bd87..979309f 100644 --- a/amaranth_soc/event.py +++ b/amaranth_soc/event.py @@ -167,8 +167,7 @@ def add(self, src): if self._frozen: raise ValueError("Event map has been frozen. Cannot add source") if not isinstance(src, Source): - raise TypeError("Event source must be an instance of event.Source, not {!r}" - .format(src)) + raise TypeError(f"Event source must be an instance of event.Source, not {src!r}") if id(src) not in self._sources: self._sources[id(src)] = src, self.size @@ -189,8 +188,7 @@ def index(self, src): Raises :exn:`KeyError` if the source is not found. """ if not isinstance(src, Source): - raise TypeError("Event source must be an instance of event.Source, not {!r}" - .format(src)) + raise TypeError(f"Event source must be an instance of event.Source, not {src!r}") _, index = self._sources[id(src)] return index diff --git a/amaranth_soc/memory.py b/amaranth_soc/memory.py index ea29411..dee9e59 100644 --- a/amaranth_soc/memory.py +++ b/amaranth_soc/memory.py @@ -131,14 +131,12 @@ def __init__(self, resource, path, start, end, width): all(name and isinstance(name, str) for name in flattened_path)): raise TypeError(f"Path must be a non-empty tuple of non-empty strings, not {path!r}") if not isinstance(start, int) or start < 0: - raise TypeError("Start address must be a non-negative integer, not {!r}" - .format(start)) + raise TypeError(f"Start address must be a non-negative integer, not {start!r}") if not isinstance(end, int) or end <= start: - raise TypeError("End address must be an integer greater than the start address, " - "not {!r}".format(end)) + raise TypeError(f"End address must be an integer greater than the start address, " + f"not {end!r}") if not isinstance(width, int) or width < 0: - raise TypeError("Width must be a non-negative integer, not {!r}" - .format(width)) + raise TypeError(f"Width must be a non-negative integer, not {width!r}") self._resource = resource self._path = tuple(path) @@ -199,16 +197,13 @@ class MemoryMap: """ def __init__(self, *, addr_width, data_width, alignment=0, name=None): if not isinstance(addr_width, int) or addr_width <= 0: - raise ValueError("Address width must be a positive integer, not {!r}" - .format(addr_width)) + raise ValueError(f"Address width must be a positive integer, not {addr_width!r}") if not isinstance(data_width, int) or data_width <= 0: - raise ValueError("Data width must be a positive integer, not {!r}" - .format(data_width)) + raise ValueError(f"Data width must be a positive integer, not {data_width!r}") if not isinstance(alignment, int) or alignment < 0: - raise ValueError("Alignment must be a non-negative integer, not {!r}" - .format(alignment)) + raise ValueError(f"Alignment must be a non-negative integer, not {alignment!r}") if name is not None and not (isinstance(name, str) and name): - raise ValueError("Name must be a non-empty string, not {!r}".format(name)) + raise ValueError(f"Name must be a non-empty string, not {name!r}") self._addr_width = addr_width self._data_width = data_width @@ -267,32 +262,28 @@ def align_to(self, alignment): Implicit next address. """ if not isinstance(alignment, int) or alignment < 0: - raise ValueError("Alignment must be a non-negative integer, not {!r}" - .format(alignment)) + raise ValueError(f"Alignment must be a non-negative integer, not {alignment!r}") self._next_addr = self._align_up(self._next_addr, max(alignment, self.alignment)) return self._next_addr def _compute_addr_range(self, addr, size, step=1, *, alignment): if addr is not None: if not isinstance(addr, int) or addr < 0: - raise ValueError("Address must be a non-negative integer, not {!r}" - .format(addr)) + raise ValueError(f"Address must be a non-negative integer, not {addr!r}") if addr % (1 << self.alignment) != 0: - raise ValueError("Explicitly specified address {:#x} must be a multiple of " - "{:#x} bytes" - .format(addr, 1 << alignment)) + raise ValueError(f"Explicitly specified address {addr:#x} must be a multiple of " + f"{1 << alignment:#x} bytes") else: addr = self._align_up(self._next_addr, alignment) if not isinstance(size, int) or size < 0: - raise ValueError("Size must be a non-negative integer, not {!r}" - .format(size)) + raise ValueError(f"Size must be a non-negative integer, not {size!r}") size = self._align_up(max(size, 1), alignment) if addr > (1 << self.addr_width) or addr + size > (1 << self.addr_width): - raise ValueError("Address range {:#x}..{:#x} out of bounds for memory map spanning " - "range {:#x}..{:#x} ({} address bits)" - .format(addr, addr + size, 0, 1 << self.addr_width, self.addr_width)) + raise ValueError(f"Address range {addr:#x}..{addr + size:#x} out of bounds for " + f"memory map spanning range {0:#x}..{1 << self.addr_width:#x} " + f"({self.addr_width} address bits)") addr_range = range(addr, addr + size, step) overlaps = self._ranges.overlaps(addr_range) @@ -301,14 +292,14 @@ def _compute_addr_range(self, addr, size, step=1, *, alignment): for overlap in overlaps: if id(overlap) in self._resources: _, _, resource_range = self._resources[id(overlap)] - overlap_descrs.append("resource {!r} at {:#x}..{:#x}" - .format(overlap, resource_range.start, resource_range.stop)) + overlap_descrs.append(f"resource {overlap!r} at {resource_range.start:#x}.." + f"{resource_range.stop:#x}") if id(overlap) in self._windows: _, window_range = self._windows[id(overlap)] - overlap_descrs.append("window {!r} at {:#x}..{:#x}" - .format(overlap, window_range.start, window_range.stop)) - raise ValueError("Address range {:#x}..{:#x} overlaps with {}" - .format(addr, addr + size, ", ".join(overlap_descrs))) + overlap_descrs.append(f"window {overlap!r} at {window_range.start:#x}.." + f"{window_range.stop:#x}") + raise ValueError(f"Address range {addr:#x}..{addr + size:#x} overlaps with " + + ", ".join(overlap_descrs)) return addr_range @@ -355,16 +346,15 @@ def add_resource(self, resource, *, name, size, addr=None, alignment=None): this memory map. """ if self._frozen: - raise ValueError("Memory map has been frozen. Cannot add resource {!r}" - .format(resource)) + raise ValueError(f"Memory map has been frozen. Cannot add resource {resource!r}") if not isinstance(resource, wiring.Component): raise TypeError(f"Resource must be a wiring.Component, not {resource!r}") if id(resource) in self._resources: _, _, addr_range = self._resources[id(resource)] - raise ValueError("Resource {!r} is already added at address range {:#x}..{:#x}" - .format(resource, addr_range.start, addr_range.stop)) + raise ValueError(f"Resource {resource!r} is already added at address range " + f"{addr_range.start:#x}..{addr_range.stop:#x}") if not (name and isinstance(name, tuple) and all(part and isinstance(part, str) for part in name)): @@ -380,8 +370,7 @@ def add_resource(self, resource, *, name, size, addr=None, alignment=None): if alignment is not None: if not isinstance(alignment, int) or alignment < 0: - raise ValueError("Alignment must be a non-negative integer, not {!r}" - .format(alignment)) + raise ValueError(f"Alignment must be a non-negative integer, not {alignment!r}") alignment = max(alignment, self.alignment) else: alignment = self.alignment @@ -470,33 +459,28 @@ def add_window(self, window, *, addr=None, sparse=None): conflicts with the name of others present in this memory map. """ if not isinstance(window, MemoryMap): - raise TypeError("Window must be a MemoryMap, not {!r}" - .format(window)) + raise TypeError(f"Window must be a MemoryMap, not {window!r}") if self._frozen: - raise ValueError("Memory map has been frozen. Cannot add window {!r}" - .format(window)) + raise ValueError(f"Memory map has been frozen. Cannot add window {window!r}") if id(window) in self._windows: _, addr_range = self._windows[id(window)] - raise ValueError("Window {!r} is already added at address range {:#x}..{:#x}" - .format(window, addr_range.start, addr_range.stop)) + raise ValueError(f"Window {window!r} is already added at address range " + f"{addr_range.start:#x}..{addr_range.stop:#x}") if window.data_width > self.data_width: - raise ValueError("Window has data width {}, and cannot be added to a memory map " - "with data width {}" - .format(window.data_width, self.data_width)) + raise ValueError(f"Window has data width {window.data_width}, and cannot be added to a " + f"memory map with data width {self.data_width}") if window.data_width != self.data_width: if sparse is None: - raise ValueError("Address translation mode must be explicitly specified " - "when adding a window with data width {} to a memory map " - "with data width {}" - .format(window.data_width, self.data_width)) + raise ValueError(f"Address translation mode must be explicitly specified when " + f"adding a window with data width {window.data_width} to a " + f"memory map with data width {self.data_width}") if not sparse and self.data_width % window.data_width != 0: - raise ValueError("Dense addressing cannot be used because the memory map " - "data width {} is not an integer multiple of window " - "data width {}" - .format(self.data_width, window.data_width)) + raise ValueError(f"Dense addressing cannot be used because the memory map " + f"data width {self.data_width} is not an integer multiple of " + f"window data width {window.data_width}") queries = window._namespace.names() if window.name is None else ((window.name,),) reasons = [] @@ -564,10 +548,10 @@ def window_patterns(self): for window, (window_start, window_stop, window_ratio) in self.windows(): const_bits = self.addr_width - window.addr_width if const_bits > 0: - const_pat = "{:0{}b}".format(window_start >> window.addr_width, const_bits) + const_pat = f"{window_start >> window.addr_width:0{const_bits}b}" else: const_pat = "" - pattern = "{}{}".format(const_pat, "-" * window.addr_width) + pattern = const_pat + "-" * window.addr_width yield window, (pattern, window_ratio) @staticmethod diff --git a/amaranth_soc/periph.py b/amaranth_soc/periph.py index 3f3b162..494ac25 100644 --- a/amaranth_soc/periph.py +++ b/amaranth_soc/periph.py @@ -24,7 +24,7 @@ class ConstantBool(ConstantValue): """ def __init__(self, value): if not isinstance(value, bool): - raise TypeError("Value must be a bool, not {!r}".format(value)) + raise TypeError(f"Value must be a bool, not {value!r}") self._value = value @property @@ -32,7 +32,7 @@ def value(self): return self._value def __repr__(self): - return "ConstantBool({})".format(self.value) + return f"ConstantBool({self.value})" class ConstantInt(ConstantValue): @@ -49,25 +49,22 @@ class ConstantInt(ConstantValue): """ def __init__(self, value, *, width=None, signed=None): if not isinstance(value, int): - raise TypeError("Value must be an integer, not {!r}" - .format(value)) + raise TypeError(f"Value must be an integer, not {value!r}") self._value = value if width is None: width = bits_for(value) if not isinstance(width, int): - raise TypeError("Width must be an integer, not {!r}" - .format(width)) + raise TypeError(f"Width must be an integer, not {width!r}") if width < bits_for(value): - raise ValueError("Width must be greater than or equal to the number of bits needed to" - " represent {}".format(value)) + raise ValueError(f"Width must be greater than or equal to the number of bits needed " + f"to represent {value}") self._width = width if signed is None: signed = value < 0 if not isinstance(signed, bool): - raise TypeError("Signedness must be a bool, not {!r}" - .format(signed)) + raise TypeError(f"Signedness must be a bool, not {signed!r}") self._signed = signed @property @@ -83,7 +80,7 @@ def signed(self): return self._signed def __repr__(self): - return "ConstantInt({}, width={}, signed={})".format(self.value, self.width, self.signed) + return f"ConstantInt({self.value}, width={self.width}, signed={self.signed})" class ConstantMap(Mapping): @@ -109,8 +106,8 @@ def __init__(self, **constants): if isinstance(value, int): value = ConstantInt(value) if not isinstance(value, ConstantValue): - raise TypeError("Constant value must be an instance of ConstantValue, not {!r}" - .format(value)) + raise TypeError(f"Constant value must be an instance of ConstantValue, not " + f"{value!r}") self._storage[key] = value def __getitem__(self, key): @@ -123,7 +120,7 @@ def __len__(self): return len(self._storage) def __repr__(self): - return "ConstantMap({})".format(list(self._storage.items())) + return f"ConstantMap({list(self._storage.items())})" class PeripheralInfo: @@ -143,21 +140,19 @@ class PeripheralInfo: """ def __init__(self, *, memory_map, irq=None, constant_map=None): if not isinstance(memory_map, MemoryMap): - raise TypeError("Memory map must be an instance of MemoryMap, not {!r}" - .format(memory_map)) + raise TypeError(f"Memory map must be an instance of MemoryMap, not {memory_map!r}") memory_map.freeze() self._memory_map = memory_map if irq is not None and not isinstance(irq, event.Source): - raise TypeError("IRQ line must be an instance of event.Source, not {!r}" - .format(irq)) + raise TypeError(f"IRQ line must be an instance of event.Source, not {irq!r}") self._irq = irq if constant_map is None: constant_map = ConstantMap() if not isinstance(constant_map, ConstantMap): - raise TypeError("Constant map must be an instance of ConstantMap, not {!r}" - .format(constant_map)) + raise TypeError(f"Constant map must be an instance of ConstantMap, not " + f"{constant_map!r}") self._constant_map = constant_map @property @@ -184,8 +179,7 @@ def irq(self): Raises :exn:`NotImplementedError` if the peripheral info does not have an IRQ line. """ if self._irq is None: - raise NotImplementedError("Peripheral info does not have an IRQ line" - .format(self)) + raise NotImplementedError("Peripheral info does not have an IRQ line") return self._irq @property