Enforce that Barcode.build() returns a singleton list

Also add some type hints.

Author: maresb

barcode/base.py

@@ -35,15 +35,17 @@ class Barcode:
     writer: BaseWriter
 
     def to_ascii(self) -> str:
-        code = self.build()
-        for i, line in enumerate(code):
-            code[i] = line.replace("1", "X").replace("0", " ")
-        return "\n".join(code)
+        code_list = self.build()
+        if not len(code_list) == 1:
+            raise RuntimeError("Code list must contain a single element.")
+        code = code_list[0]
+        return code.replace("1", "X").replace("0", " ")
 
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}({self.get_fullcode()!r})>"
 
     def build(self) -> list[str]:
+        """Return a singleton list with a string encoding the barcode as 1s and 0s."""
         raise NotImplementedError
 
     def get_fullcode(self):
@@ -101,5 +103,8 @@ def render(self, writer_options: dict | None = None, text: str | None = None):
             else:
                 options["text"] = self.get_fullcode()
         self.writer.set_options(options)
-        code = self.build()
-        return self.writer.render(code)
+        code_list = self.build()
+        if not len(code_list) == 1:
+            raise RuntimeError("Code list must contain a single element.")
+        code = code_list[0]
+        return self.writer.render([code])

barcode/codabar.py

@@ -41,7 +41,7 @@ def __str__(self) -> str:
     def get_fullcode(self):
         return self.code
 
-    def build(self):
+    def build(self) -> list[str]:
         try:
             data = (
                 codabar.STARTSTOP[self.code[0]] + "n"

barcode/codex.py

@@ -4,7 +4,9 @@
 """
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
 from typing import Collection
+from typing import Literal
 
 from barcode.base import Barcode
 from barcode.charsets import code39
@@ -13,6 +15,9 @@
 from barcode.errors import IllegalCharacterError
 from barcode.errors import NumberOfDigitsError
 
+if TYPE_CHECKING:
+    from barcode.writer import BaseWriter
+
 __docformat__ = "restructuredtext en"
 
 # Sizes
@@ -66,12 +71,13 @@ def calculate_checksum(self):
                 return k
         return None
 
-    def build(self):
+    def build(self) -> list[str]:
         chars = [code39.EDGE]
         for char in self.code:
             chars.append(code39.MAP[char][1])
         chars.append(code39.EDGE)
-        return [code39.MIDDLE.join(chars)]
+        result = code39.MIDDLE.join(chars)
+        return [result]
 
     def render(self, writer_options=None, text=None):
         options = {"module_width": MIN_SIZE, "quiet_zone": MIN_QUIET_ZONE}
@@ -135,8 +141,12 @@ class Code128(Barcode):
     """
 
     name = "Code 128"
+    _charset: Literal["A", "B", "C"]
+    code: str
+    writer: BaseWriter
+    buffer: str
 
-    def __init__(self, code, writer=None) -> None:
+    def __init__(self, code: str, writer=None) -> None:
         self.code = code
         self.writer = writer or self.default_writer()
         self._charset = "B"
@@ -147,13 +157,15 @@ def __str__(self) -> str:
         return self.code
 
     @property
-    def encoded(self):
+    def encoded(self) -> list[int]:
         return self._build()
 
-    def get_fullcode(self):
+    def get_fullcode(self) -> str:
         return self.code
 
-    def _new_charset(self, which):
+    def _new_charset(self, which: Literal["A", "B", "C"]) -> list[int]:
+        if which == self._charset:
+            raise ValueError(f"Already in charset {which}")
         if which == "A":
             code = self._convert("TO_A")
         elif which == "B":
@@ -163,11 +175,11 @@ def _new_charset(self, which):
         self._charset = which
         return [code]
 
-    def _maybe_switch_charset(self, pos):
+    def _maybe_switch_charset(self, pos: int) -> list[int]:
         char = self.code[pos]
         next_ = self.code[pos : pos + 10]
 
-        def look_next():
+        def look_next() -> bool:
             digits = 0
             for c in next_:
                 if c.isdigit():
@@ -176,7 +188,7 @@ def look_next():
                     break
             return digits > 3
 
-        codes = []
+        codes: list[int] = []
         if self._charset == "C" and not char.isdigit():
             if char in code128.B:
                 codes = self._new_charset("B")
@@ -197,7 +209,7 @@ def look_next():
                 codes = self._new_charset("B")
         return codes
 
-    def _convert(self, char):
+    def _convert(self, char: str) -> int:
         if self._charset == "A":
             return code128.A[char]
         if self._charset == "B":
@@ -215,19 +227,19 @@ def _convert(self, char):
             f"Character {char} could not be converted in charset {self._charset}."
         )
 
-    def _try_to_optimize(self, encoded):
+    def _try_to_optimize(self, encoded: list[int]) -> list[int]:
         if encoded[1] in code128.TO:
             encoded[:2] = [code128.TO[encoded[1]]]
         return encoded
 
-    def _calculate_checksum(self, encoded):
+    def _calculate_checksum(self, encoded: list[int]) -> int:
         cs = [encoded[0]]
         for i, code_num in enumerate(encoded[1:], start=1):
             cs.append(i * code_num)
         return sum(cs) % 103
 
-    def _build(self):
-        encoded = [code128.START_CODES[self._charset]]
+    def _build(self) -> list[int]:
+        encoded: list[int] = [code128.START_CODES[self._charset]]
         for i, char in enumerate(self.code):
             encoded.extend(self._maybe_switch_charset(i))
             code_num = self._convert(char)
@@ -240,7 +252,7 @@ def _build(self):
             self._buffer = ""
         return self._try_to_optimize(encoded)
 
-    def build(self):
+    def build(self) -> list[str]:
         encoded = self._build()
         encoded.append(self._calculate_checksum(encoded))
         code = ""

barcode/ean.py

@@ -94,11 +94,11 @@ def calculate_checksum(self, value: str | None = None) -> int:
         oddsum = sum(int(x) for x in ean_without_checksum[-1::-2])
         return (10 - ((evensum + oddsum * 3) % 10)) % 10
 
-    def build(self):
+    def build(self) -> list[str]:
         """Builds the barcode pattern from `self.ean`.
 
         :returns: The pattern as string
-        :rtype: String
+        :rtype: List containing the string as a single element
         """
         code = self.EDGE[:]
         pattern = _ean.LEFT_PATTERN[int(self.ean[0])]
@@ -110,15 +110,16 @@ def build(self):
         code += self.EDGE
         return [code]
 
-    def to_ascii(self):
+    def to_ascii(self) -> str:
         """Returns an ascii representation of the barcode.
 
         :rtype: String
         """
-        code = self.build()
-        for i, line in enumerate(code):
-            code[i] = line.replace("G", "|").replace("1", "|").replace("0", " ")
-        return "\n".join(code)
+        code_list = self.build()
+        if not len(code_list) == 1:
+            raise RuntimeError("Code list must contain a single element.")
+        code = code_list[0]
+        return code.replace("G", "|").replace("1", "|").replace("0", " ")
 
     def render(self, writer_options=None, text=None):
         options = {"module_width": SIZES["SC2"]}
@@ -171,11 +172,10 @@ class EuropeanArticleNumber8(EuropeanArticleNumber13):
 
     digits = 7
 
-    def build(self):
+    def build(self) -> list[str]:
         """Builds the barcode pattern from `self.ean`.
 
-        :returns: The pattern as string
-        :rtype: String
+        :returns: A list containing the string as a single element
         """
         code = self.EDGE[:]
         for number in self.ean[:4]:

barcode/itf.py

@@ -48,7 +48,7 @@ def __str__(self) -> str:
     def get_fullcode(self):
         return self.code
 
-    def build(self):
+    def build(self) -> list[str]:
         data = itf.START
         for i in range(0, len(self.code), 2):
             bars_digit = int(self.code[i])

barcode/upc.py

@@ -77,11 +77,11 @@ def sum_(x, y):
 
         return 10 - check
 
-    def build(self):
+    def build(self) -> list[str]:
         """Builds the barcode pattern from 'self.upc'
 
         :return: The pattern as string
-        :rtype: str
+        :rtype: List containing the string as a single element
         """
         code = _upc.EDGE[:]
 
@@ -97,16 +97,17 @@ def build(self):
 
         return [code]
 
-    def to_ascii(self):
+    def to_ascii(self) -> str:
         """Returns an ascii representation of the barcode.
 
         :rtype: str
         """
 
-        code = self.build()
-        for i, line in enumerate(code):
-            code[i] = line.replace("1", "|").replace("0", "_")
-        return "\n".join(code)
+        code_list = self.build()
+        if len(code_list) != 1:
+            raise RuntimeError("Code list must contain a single element.")
+        code = code_list[0]
+        return code.replace("1", "|").replace("0", "_")
 
     def render(self, writer_options=None, text=None):
         options = {"module_width": 0.33}

barcode/writer.py

@@ -362,9 +362,9 @@ def _create_text(self, xpos, ypos):
             attributes = {
                 "x": SIZE.format(xpos),
                 "y": SIZE.format(ypos),
-                "style": "fill:{};font-size:{}pt;text-anchor:middle;".format(
-                    self.foreground,
-                    self.font_size,
+                "style": (
+                    f"fill:{self.foreground};"
+                    f"font-size:{self.font_size}pt;text-anchor:middle;"
                 ),
             }
             _set_attributes(element, **attributes)