pybarcodes 1.0.3__tar.gz → 1.2.2__tar.gz

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybarcodes
-Version: 1.0.3
+Version: 1.2.2
 Summary: A Python package for barcode generation
 Author-email: atbuy <buy@atbuy.dev>
 License-Expression: MIT
@@ -48,7 +48,7 @@ pybarcodes
     :alt: PyPI supported Python versions
 
 
-This is a python package to create and read barcodes
+This is a Python package to create barcodes.
 You can create file-like objects, text files and images from just a barcode number.
 Image generation is fast so it can be used to create images in bulk.
 

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/README.rst

@@ -16,7 +16,7 @@ pybarcodes
     :alt: PyPI supported Python versions
 
 
-This is a python package to create and read barcodes
+This is a Python package to create barcodes.
 You can create file-like objects, text files and images from just a barcode number.
 Image generation is fast so it can be used to create images in bulk.
 

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/pybarcodes/__init__.py

@@ -7,7 +7,7 @@ __title__ = "pybarcodes"
 __author__ = "atbuy"
 __license__ = "MIT"
 __copyright__ = "Copyright 2021-present atbuy"
-__version__ = (1, 0, 3)
+__version__ = (1, 2, 2)
 
 VersionInfo = namedtuple("VersionInfo", "major minor patch")
 

pybarcodes-1.2.2/pybarcodes/barcode.py

@@ -0,0 +1,322 @@
+from collections import namedtuple
+from io import BytesIO
+from os import PathLike
+from typing import Any, Optional, Union
+
+from PIL import Image, ImageDraw, ImageFont
+
+BarcodeInput = Union[str, int]
+PathInput = Union[str, PathLike[str]]
+RenderSize = tuple[int, int]
+RenderOptions = tuple[int, int, int, int, int]
+
+
+class Barcode:
+    """A base class for all barcode types"""
+
+    BARCODE_SIZE: RenderSize
+    BARCODE_FONT_SIZE: int
+    BARCODE_COLUMN_NUMBER: int
+    BARCODE_PADDING: Any
+
+    def __init__(self, barcode: BarcodeInput):
+        self.code = self.normalize(barcode)
+
+    @classmethod
+    def validate(cls, barcode: BarcodeInput) -> None:
+        """Validate barcode input."""
+
+    @classmethod
+    def normalize(cls, barcode: BarcodeInput) -> str:
+        """Return the normalized barcode value used by the instance."""
+
+        cls.validate(barcode)
+        return str(barcode)
+
+    @property
+    def image(self) -> Image.Image:
+        """Retrieves and returns the PIL.Image object with the barcode
+
+        Returns
+        -------
+        PIl.Image.Image:
+            The barcode image
+        """
+
+        return self.render()
+
+    def render(
+        self,
+        size: Optional[RenderSize] = None,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+    ) -> Image.Image:
+        """Create a PIL Image object for the barcode."""
+
+        img = self._get_barcode_image(
+            module_width=module_width,
+            bar_height=bar_height,
+            quiet_zone=quiet_zone,
+            font_size=font_size,
+            draw_text=draw_text,
+        )
+        if size is not None:
+            resampling = getattr(Image, "Resampling", Image)
+            img = img.resize(size, resampling.NEAREST)
+        return img
+
+    def save(
+        self,
+        path: PathInput,
+        size: Optional[RenderSize] = None,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+        **save_kwargs: Any,
+    ) -> Image.Image:
+        """Create a PIL Image object and save it to the path given.
+
+        It also returns that image object to the caller.
+
+        Parameters
+        ----------
+        path: str
+            The path to save the image to
+
+        Returns
+        -------
+        Returns a PIL Image object to the caller
+        """
+
+        img = self.render(
+            size=size,
+            module_width=module_width,
+            bar_height=bar_height,
+            quiet_zone=quiet_zone,
+            font_size=font_size,
+            draw_text=draw_text,
+        )
+        img.save(path, **save_kwargs)
+        return img
+
+    def show(self) -> None:
+        """Shows the barcode image"""
+
+        self.render().show()
+
+    def to_text_bytes(self, encoding: str = "ascii") -> bytes:
+        """Return the normalized barcode text as bytes."""
+
+        return self.code.encode(encoding)
+
+    def to_text_bytesio(self, encoding: str = "ascii") -> BytesIO:
+        """
+        Write the barcode to a BytesIO object
+
+        Returns
+        -------
+        Returns the BytesIO object created
+        """
+
+        obj = BytesIO(self.to_text_bytes(encoding=encoding))
+        obj.seek(0)
+        return obj
+
+    def to_bytesio(self, encoding: str = "ascii") -> BytesIO:
+        """Return the normalized barcode text in a BytesIO object."""
+
+        return self.to_text_bytesio(encoding=encoding)
+
+    def to_image_bytesio(
+        self,
+        format: str = "PNG",
+        size: Optional[RenderSize] = None,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+        **save_kwargs: Any,
+    ) -> BytesIO:
+        """Return the rendered barcode image in a BytesIO object."""
+
+        obj = BytesIO()
+        self.render(
+            size=size,
+            module_width=module_width,
+            bar_height=bar_height,
+            quiet_zone=quiet_zone,
+            font_size=font_size,
+            draw_text=draw_text,
+        ).save(obj, format=format, **save_kwargs)
+        obj.seek(0)
+        return obj
+
+    def to_image_bytes(
+        self,
+        format: str = "PNG",
+        size: Optional[RenderSize] = None,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+        **save_kwargs: Any,
+    ) -> bytes:
+        """Return the rendered barcode image as bytes."""
+
+        return self.to_image_bytesio(
+            format=format,
+            size=size,
+            module_width=module_width,
+            bar_height=bar_height,
+            quiet_zone=quiet_zone,
+            font_size=font_size,
+            draw_text=draw_text,
+            **save_kwargs,
+        ).getvalue()
+
+    def write(self, path: PathInput, encoding: str = "ascii") -> None:
+        """
+        Tries to save the barcode to a text file
+
+        Parameters
+        ----------
+        path: str
+            The path of the file
+        """
+        with open(path, "w", encoding=encoding) as file:
+            file.write(self.code)
+
+    @staticmethod
+    def _positive_int(value: int, name: str) -> int:
+        value = int(value)
+        if value <= 0:
+            raise ValueError(f"{name} must be greater than 0.")
+        return value
+
+    def _get_render_options(
+        self,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+    ) -> RenderOptions:
+        padding = self.BARCODE_PADDING
+        selected_size, default_font_size = self.BARCODE_SIZE, self.BARCODE_FONT_SIZE
+
+        module_width = (
+            self._get_column_size()
+            if module_width is None
+            else self._positive_int(module_width, "module_width")
+        )
+        bar_height = (
+            selected_size[1]
+            if bar_height is None
+            else self._positive_int(bar_height, "bar_height")
+        )
+        quiet_zone = (
+            padding.width // 2
+            if quiet_zone is None
+            else self._positive_int(quiet_zone, "quiet_zone")
+        )
+        font_size = (
+            default_font_size
+            if font_size is None
+            else self._positive_int(font_size, "font_size")
+        )
+        text_padding = padding.height if draw_text else 0
+
+        return module_width, bar_height, quiet_zone, font_size, text_padding
+
+    def _get_default_font(self, font_size: int) -> ImageFont.ImageFont:
+        try:
+            return ImageFont.load_default(size=font_size)
+        except TypeError:
+            return ImageFont.load_default()
+
+    def _get_barcode_image(
+        self,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+    ) -> Image.Image:
+        """Creates a PIL Image from the binary string of the barcode
+
+        Returns
+        -------
+        A PIL Image with the barcode is returned to the caller.
+        """
+
+        module_width, bar_height, quiet_zone, font_size, text_padding = (
+            self._get_render_options(
+                module_width=module_width,
+                bar_height=bar_height,
+                quiet_zone=quiet_zone,
+                font_size=font_size,
+                draw_text=draw_text,
+            )
+        )
+
+        binary_string = self.get_binary_string
+
+        # Create the image for the barcode
+        img = Image.new(
+            "RGB",
+            (module_width * len(binary_string), bar_height),
+            (255, 255, 255),
+        )
+
+        index = 0
+        for digit in binary_string:
+            color = (0, 0, 0) if digit == "1" else (255, 255, 255)
+            column = Image.new("RGB", (module_width, img.height), color)
+            img.paste(column, (index, 0))
+            index += module_width
+
+        base = Image.new(
+            "RGB",
+            (img.width + quiet_zone * 2, bar_height + text_padding),
+            (255, 255, 255),
+        )
+
+        # Paste the barcode on the center of the padded base
+        Point = namedtuple("Point", "x y")
+        base_center = Point(base.width // 2, base.height // 2)
+
+        base.paste(img, (quiet_zone, text_padding // 2))
+
+        if not draw_text:
+            return base
+
+        draw = ImageDraw.Draw(base)
+        font = self._get_default_font(font_size)
+
+        text_width = draw.textlength(self.code, font)
+        x = base_center.x - text_width // 2
+        y = text_padding // 2 + img.height
+
+        draw.text((x, y), self.code, (0, 0, 0), font=font)
+        return base
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return self.code == other.code
+        elif isinstance(other, str):
+            return self.code == other
+
+        return False
+
+    def __str__(self) -> str:
+        return f"<{self.__class__.__name__}(code={self.code})>"
+
+    def __repr__(self) -> str:
+        return self.__str__()

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/pybarcodes/codes.py

@@ -1,10 +1,9 @@
 from collections import namedtuple
-from pathlib import Path
-from typing import Union
+from typing import Optional, Union
 
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw
 
-from .barcode import Barcode
+from .barcode import Barcode, BarcodeInput
 from .codings import codex as CODEXCoding
 from .exceptions import IncorrectFormat
 
@@ -12,10 +11,10 @@ Size = namedtuple("Size", "width height")
 
 
 class Code(Barcode):
-    def __init__(self, barcode: Union[str, int]):
+    def __init__(self, barcode: BarcodeInput):
         super().__init__(barcode)
 
-        self.code = self._clean_code()
+        self.checksum = self.code[-1]
 
         # Calculate the variable width of the barcod
         # 6 pixels for each character
@@ -36,6 +35,39 @@ class Code(Barcode):
         # Calculate how many character will have to be written
         self.BARCODE_COLUMN_NUMBER = column_size
 
+    @classmethod
+    def validate(cls, barcode: BarcodeInput) -> None:
+        code = str(barcode).upper()
+
+        for char in code:
+            if char not in CODEXCoding.CODES or char == "_":
+                raise IncorrectFormat(
+                    f"Character {char} is not supported by {cls.__name__}"
+                )
+
+    @classmethod
+    def normalize(cls, barcode: BarcodeInput) -> str:
+        cls.validate(barcode)
+        code = str(barcode).upper()
+        reference = cls._calculate_checksum(code)
+        checkchar = CODEXCoding.REFERENCE_NUMBERS[reference]
+        return code + checkchar
+
+    @classmethod
+    def _calculate_checksum(cls, barcode: str) -> int:
+        code = barcode.upper()
+        for char in code:
+            if char not in CODEXCoding.REFERENCE_DIGITS:
+                raise IncorrectFormat(
+                    f"Character {char} is not supported by {cls.__name__}"
+                )
+
+        if len(code) == 1:
+            return CODEXCoding.REFERENCE_DIGITS[code]
+
+        numbers = [CODEXCoding.REFERENCE_DIGITS[char] for char in list(code)]
+        return sum(numbers) % 43
+
     @property
     def get_binary_string(self) -> str:
         """Converts the code to the binary string that it produces.
@@ -61,7 +93,7 @@ class Code(Barcode):
 
         return self._convert_to_binary(code)
 
-    def calculate_checksum(self, barcode: Union[str, "CODE39"] = None) -> int:
+    def calculate_checksum(self, barcode: Optional[Union[str, "CODE39"]] = None) -> int:
         """Calculate the checksum of the barcode
 
         Parameters
@@ -85,25 +117,21 @@ class Code(Barcode):
             barcode = barcode.code
         elif isinstance(barcode, str):
             pass
-        elif barcode is None or self.code:
+        elif barcode is None:
             return CODEXCoding.REFERENCE_DIGITS[self.checksum]
         else:
             raise TypeError(f"Can't accept type {type(barcode)}")
 
-        barcode = barcode.upper()
-
-        # If the barcode is only 1 character long
-        # Then the check sum will be that same character
-        if len(barcode) == 1:
-            return CODEXCoding.REFERENCE_DIGITS[barcode]
-
-        # Find the number value of each digit
-        numbers = [CODEXCoding.REFERENCE_DIGITS[char] for char in list(barcode)]
-
-        # Calculate the modulo 43 of the sum
-        return sum(numbers) % 43
+        return self._calculate_checksum(barcode)
 
-    def _get_barcode_image(self) -> Image.Image:
+    def _get_barcode_image(
+        self,
+        module_width: Optional[int] = None,
+        bar_height: Optional[int] = None,
+        quiet_zone: Optional[int] = None,
+        font_size: Optional[int] = None,
+        draw_text: bool = True,
+    ) -> Image.Image:
         """Creates a PIL Image from the binary string of the barcode.
 
         Returns
@@ -111,33 +139,25 @@ class Code(Barcode):
         A PIL Image with the barcode is returned to the caller.
         """
 
-        # Get the padding around the barcode
-        padding = self.BARCODE_PADDING
-
-        # Get the image's width and height
-        selected_size, font_size = self.BARCODE_SIZE, self.BARCODE_FONT_SIZE
-
-        # This is for the whitespace around the barcode
-        padded_size = (
-            selected_size[0] + padding.width,
-            selected_size[1] + padding.height,
+        module_width, bar_height, quiet_zone, font_size, text_padding = (
+            self._get_render_options(
+                module_width=module_width,
+                bar_height=bar_height,
+                quiet_zone=quiet_zone,
+                font_size=font_size,
+                draw_text=draw_text,
+            )
         )
 
-        # Get each column's width and height
-        column_size = self._get_column_size()
-
-        # Create a white base image to paste the barcode on
-        base = Image.new("RGB", padded_size, (255, 255, 255))
-
         # Create the image to write the columns
         img = Image.new(
             "RGB",
-            (column_size * self.BARCODE_COLUMN_NUMBER, selected_size[1]),
+            (module_width * self.BARCODE_COLUMN_NUMBER, bar_height),
             (255, 255, 255),
         )
 
         # This is the spacing we are going to add after each digit
-        space = Image.new("RGB", (column_size, img.height), (255, 255, 255))
+        space = Image.new("RGB", (module_width, img.height), (255, 255, 255))
 
         # Create a binary string representation of the barcode digits
         binary_string = self.get_binary_string
@@ -151,12 +171,12 @@ class Code(Barcode):
             # If the character is a ` ` (space) then we write 3 times the size on the spacing
             # We also need to add a single width column of spacing after each digit
             if digit == "1":
-                column_width = round(column_size * 3)
+                column_width = module_width * 3
             elif digit == " ":
-                column_width = round(column_size * 3)
+                column_width = module_width * 3
                 color = (255, 255, 255)
             else:
-                column_width = column_size
+                column_width = module_width
 
             # First paste the column
             column = Image.new("RGB", (column_width, img.height), color)
@@ -171,31 +191,30 @@ class Code(Barcode):
         # Crop redundant whitespace after barcode
         img = img.crop((0, 0, index, img.height))
 
+        base = Image.new(
+            "RGB",
+            (img.width + quiet_zone * 2, bar_height + text_padding),
+            (255, 255, 255),
+        )
+
         # Paste the barcode on the center of the padded base
         Point = namedtuple("Point", "x y")
         base_center = Point(base.width // 2, base.height // 2)
-        img_center = Point(img.width // 2, img.height // 2)
 
-        base.paste(img, (base_center.x - img_center.x, base_center.y - img_center.y))
+        base.paste(img, (quiet_zone, text_padding // 2))
 
-        # Write the digits at the bottom
-        cwd = Path(__file__).parent
-        font_path = str(cwd.joinpath(cwd, "fonts", "arial.ttf"))
+        if not draw_text:
+            return base
 
         draw = ImageDraw.Draw(base)
-        font = ImageFont.truetype(font_path, font_size)
+        font = self._get_default_font(font_size)
 
         text_width = draw.textlength(self.code, font)
         x = base_center.x - text_width // 2
-        y = base.height - (base.height - img.height) // 2
+        y = text_padding // 2 + img.height
 
         draw.text((x, y), self.code, (0, 0, 0), font=font)
 
-        # And now we crop spare white space around base image
-        start_index = (base_center.x - img_center.x) - padding.width // 2
-        end_index = (base_center.x - img_center.x) + padding.width // 2
-
-        base.crop((start_index, 0, end_index, base.height))
         return base
 
     def _convert_to_binary(self, string: str) -> str:
@@ -225,17 +244,7 @@ class Code(Barcode):
         and the check digit is calculated if not given
         """
 
-        for char in self.code:
-            if char not in CODEXCoding.CODES or char == "_":
-                raise IncorrectFormat(
-                    f"Character {char} is not supported by {self.__class__.__name__}"
-                )
-
-        reference = self.calculate_checksum(self.code)
-        checkchar = CODEXCoding.REFERENCE_NUMBERS[reference]
-
-        self.checksum = checkchar
-        return self.code + str(checkchar)
+        return self.normalize(self.code)
 
     def _trim(self, code: str) -> str:
         """Removes the start and stop characters from the barcode
@@ -282,5 +291,5 @@ class CODE39(Code):
     BARCODE_FONT_SIZE = 30
     BARCODE_PADDING = Size(50, 100)
 
-    def __init__(self, barcode: Union[str, int]):
-        super().__init__(barcode.upper())
+    def __init__(self, barcode: BarcodeInput):
+        super().__init__(barcode)

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/pybarcodes/ean.py

@@ -1,7 +1,7 @@
 from collections import namedtuple
 from typing import Union
 
-from .barcode import Barcode
+from .barcode import Barcode, BarcodeInput
 from .codings import ean as EANCoding
 from .exceptions import IncorrectFormat
 
@@ -15,20 +15,30 @@ class EAN(Barcode):
     Shouldn't be used directly and it's subclasses are preferred
     """
 
-    def __init__(self, barcode: Union[str, int]):
+    def __init__(self, barcode: BarcodeInput):
         super().__init__(barcode)
 
-        if not self.code.isdigit():
+    @classmethod
+    def validate(cls, barcode: BarcodeInput) -> None:
+        code = str(barcode)
+
+        if not code.isdigit():
             raise IncorrectFormat("Barcode can't contain non-digit characters.")
 
-        # Do some error checking
-        if isinstance(self.code, str):
-            if len(self.code) < self.BARCODE_LENGTH:
-                classname = self.__class__.__name__
-                error = f"{classname} should be at least {self.BARCODE_LENGTH} digits long, not {len(self.code)}."
-                raise IncorrectFormat(error)
-            else:
-                self.code = self._clean_code()
+        if len(code) < cls.BARCODE_LENGTH:
+            classname = cls.__name__
+            error = (
+                f"{classname} should be at least {cls.BARCODE_LENGTH} digits long, "
+                f"not {len(code)}."
+            )
+            raise IncorrectFormat(error)
+
+    @classmethod
+    def normalize(cls, barcode: BarcodeInput) -> str:
+        cls.validate(barcode)
+        code = str(barcode)[: cls.BARCODE_LENGTH]
+        check_digit = cls.calculate_checksum(code)
+        return code + str(check_digit)
 
     @property
     def get_binary_string(self) -> str:
@@ -112,31 +122,21 @@ class EAN(Barcode):
         else:
             raise TypeError(f"Can't accept type {type(barcode)}")
 
-        if len(barcode) >= cls.BARCODE_LENGTH:
-            barcode = barcode[: cls.BARCODE_LENGTH]
-            # Here there is no check digit so it's calculated
-            digits = list(map(int, list(barcode)))
-
-            # Get even and odd indeces of the digits
-            weighted_odd = digits[1::2]
-            weighted_even = digits[::2]
+        cls.validate(barcode)
+        barcode = barcode[: cls.BARCODE_LENGTH]
 
-            # Calculate the checksum
-            checksum = (
-                sum(weighted_odd) * cls.WEIGHTS.ODD
-                + sum(weighted_even) * cls.WEIGHTS.EVEN
-            )
-            if checksum % 10 == 0:
-                return 0
+        # Here there is no check digit so it's calculated
+        digits = list(map(int, list(barcode)))
 
-            # Find the closest multiple of 10, that is equal to
-            # or higher than the checksum and return the difference
-            closest10 = ((checksum // 10) * 10) + 10
-            return closest10 % checksum
+        # Get even and odd indeces of the digits
+        weighted_odd = digits[1::2]
+        weighted_even = digits[::2]
 
-        raise IncorrectFormat(
-            f"Barcode should be at least {cls.BARCODE_LENGTH} digits long."
+        # Calculate the checksum
+        checksum = (
+            sum(weighted_odd) * cls.WEIGHTS.ODD + sum(weighted_even) * cls.WEIGHTS.EVEN
         )
+        return (10 - checksum % 10) % 10
 
     def _get_column_size(self) -> int:
         """Finds and returns what the width of each column should be
@@ -157,11 +157,7 @@ class EAN(Barcode):
         and the check digit is calculated if not given
         """
         if len(self.code) >= self.BARCODE_LENGTH:
-            code = self.code[: self.BARCODE_LENGTH]
-
-            # Calculate the checksum digit
-            check_digit = self.calculate_checksum(code)
-            return code + str(check_digit)
+            return self.normalize(self.code)
 
 
 class EAN14(EAN):
@@ -191,7 +187,7 @@ class EAN14(EAN):
     WEIGHTS = Weights(1, 3)
     HAS_STRUCTURE = True
 
-    def __init__(self, barcode: Union[str, int]):
+    def __init__(self, barcode: BarcodeInput):
         super().__init__(barcode)
 
 
@@ -222,7 +218,7 @@ class EAN13(EAN):
     WEIGHTS = Weights(3, 1)
     HAS_STRUCTURE = True
 
-    def __init__(self, barcode: Union[str, int]):
+    def __init__(self, barcode: BarcodeInput):
         super().__init__(barcode)
 
 
@@ -253,7 +249,7 @@ class EAN8(EAN):
     WEIGHTS = Weights(1, 3)
     HAS_STRUCTURE = False
 
-    def __init__(self, barcode: Union[str, int]):
+    def __init__(self, barcode: BarcodeInput):
         super().__init__(barcode)
 
 
@@ -274,7 +270,17 @@ class JAN(EAN13, EAN):
         The padding around the actual barcode
     """
 
-    def __init__(self, barcode: Union[str, int]):
+    @classmethod
+    def validate(cls, barcode: BarcodeInput) -> None:
+        super().validate(barcode)
+
+        code = str(barcode)
+        if code[:2] not in ("45", "49"):
+            raise IncorrectFormat(
+                "JAN type barcodes need to start with country code 45 or 49."
+            )
+
+    def __init__(self, barcode: BarcodeInput):
         super().__init__(barcode)
 
         if self.code[:2] not in ("45", "49"):

pybarcodes-1.2.2/pybarcodes/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561 typed packages.

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/pybarcodes.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybarcodes
-Version: 1.0.3
+Version: 1.2.2
 Summary: A Python package for barcode generation
 Author-email: atbuy <buy@atbuy.dev>
 License-Expression: MIT
@@ -48,7 +48,7 @@ pybarcodes
     :alt: PyPI supported Python versions
 
 
-This is a python package to create and read barcodes
+This is a Python package to create barcodes.
 You can create file-like objects, text files and images from just a barcode number.
 Image generation is fast so it can be used to create images in bulk.
 

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/pybarcodes.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ pybarcodes/barcode.py
 pybarcodes/codes.py
 pybarcodes/ean.py
 pybarcodes/exceptions.py
+pybarcodes/py.typed
 pybarcodes.egg-info/PKG-INFO
 pybarcodes.egg-info/SOURCES.txt
 pybarcodes.egg-info/dependency_links.txt
@@ -14,6 +15,7 @@ pybarcodes.egg-info/top_level.txt
 pybarcodes/codings/__init__.py
 pybarcodes/codings/codex.py
 pybarcodes/codings/ean.py
-pybarcodes/fonts/arial.ttf
 tests/test_codes.py
-tests/test_ean.py
+tests/test_ean.py
+tests/test_images.py
+tests/test_spec_fixtures.py

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pybarcodes"
-version = "1.0.3"
+version = "1.2.2"
 description = "A Python package for barcode generation"
 authors = [{ name = "atbuy", email = "buy@atbuy.dev" }]
 license = "MIT"
@@ -35,6 +35,7 @@ dependencies = ["pillow>8,<13"]
 
 [dependency-groups]
 dev = ["pre-commit==4.6.0", "ruff==0.15.12"]
+docs = ["numpydoc==1.8.0", "sphinx-rtd-theme==3.0.2"]
 tests = ["pytest==9.0.3", "pytest-cov==7.1.0"]
 
 [project.urls]
@@ -44,11 +45,14 @@ Repository = "https://github.com/atbuy/pybarcodes"
 "Source Code" = "https://github.com/atbuy/pybarcodes"
 "CI/CD" = "https://github.com/atbuy/pybarcodes/actions"
 
+[tool.pytest.ini_options]
+addopts = "--cov-fail-under=90"
+
 [tool.setuptools.packages.find]
 include = ["pybarcodes*"]
 
 [tool.setuptools.package-data]
-pybarcodes = ["fonts/*.ttf"]
+pybarcodes = ["py.typed"]
 
 [build-system]
 requires = ["setuptools"]

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/tests/test_codes.py

@@ -1,3 +1,5 @@
+import pytest
+
 from pybarcodes import CODE39
 from pybarcodes.exceptions import IncorrectFormat
 
@@ -15,12 +17,17 @@ def test_code39():
 
     assert barcode.calculate_checksum(code) == 40
     assert barcode.calculate_checksum() == 40
+    assert CODE39.normalize("abc123") == CODE39("abc123").code
+    assert CODE39(123).code == CODE39.normalize(123)
+    assert CODE39.validate("abc123") is None
+
+    with pytest.raises(IncorrectFormat):
+        CODE39("^")
 
-    try:
-        code = "^"
-        barcode = CODE39(code)
-    except IncorrectFormat:
-        pass
+    with pytest.raises(IncorrectFormat):
+        barcode.calculate_checksum("^")
+    with pytest.raises(IncorrectFormat):
+        CODE39.validate("^")
 
     binary_string = barcode.get_binary_string
     start_char = binary_string[:6]

{pybarcodes-1.0.3 → pybarcodes-1.2.2}/tests/test_ean.py

@@ -1,3 +1,5 @@
+import pytest
+
 from pybarcodes import EAN8, EAN13, EAN14, JAN
 from pybarcodes.exceptions import IncorrectFormat
 
@@ -20,6 +22,8 @@ def test_ean13():
 
     assert barcode == code + "1"
     assert barcode == barcode2
+    assert EAN13.normalize(code) == code + "1"
+    assert EAN13.validate(code) is None
 
     # Check if the checksum digit is calculated correctly
     # The check digit should be `1`
@@ -32,11 +36,8 @@ def test_ean13():
     # The check digit is calculated when instansiating
     assert barcode == "4006381333931"
 
-    try:
-        code = "1"
-        barcode = EAN13(code)
-    except IncorrectFormat:
-        pass
+    with pytest.raises(IncorrectFormat):
+        EAN13("1")
 
     # Check if guards are in the correct positions
     binary_string = barcode.get_binary_string
@@ -48,6 +49,11 @@ def test_ean13():
     assert center_guard == "01010"
 
 
+def test_ean13_checksum_edge_cases():
+    assert EAN13.calculate_checksum("000000000001") == 7
+    assert EAN13("000000000001") == "0000000000017"
+
+
 def test_ean8():
     code = "0123456"
     barcode = EAN8(code)
@@ -72,11 +78,8 @@ def test_ean8():
     # The check digit is calculated when instansiating
     assert barcode == "01234565"
 
-    try:
-        code = "1"
-        barcode = EAN8(code)
-    except IncorrectFormat:
-        pass
+    with pytest.raises(IncorrectFormat):
+        EAN8("1")
 
     # Check if guards in correct positions
     binary_string = barcode.get_binary_string
@@ -88,6 +91,11 @@ def test_ean8():
     assert center_guard == "01010"
 
 
+def test_ean8_checksum_edge_cases():
+    assert EAN8.calculate_checksum("0000001") == 7
+    assert EAN8("0000001") == "00000017"
+
+
 def test_ean14():
     code = "4070071967072013242346"
     barcode = EAN14(code)
@@ -109,11 +117,8 @@ def test_ean14():
     # The check digit is calculated when instansiating
     assert barcode == "40700719670720"
 
-    try:
-        code = "1"
-        barcode = EAN14(code)
-    except IncorrectFormat:
-        pass
+    with pytest.raises(IncorrectFormat):
+        EAN14("1")
 
     # Check if guards in correct positions
     binary_string = barcode.get_binary_string
@@ -125,6 +130,11 @@ def test_ean14():
     assert center_guard == "01010"
 
 
+def test_ean14_checksum_edge_cases():
+    assert EAN14.calculate_checksum("0000000000001") == 7
+    assert EAN14("0000000000001") == "00000000000017"
+
+
 def test_jan():
     code = "450638133393"
     barcode = JAN(code)
@@ -143,6 +153,8 @@ def test_jan():
 
     assert barcode == code + "6"
     assert barcode == barcode2
+    assert JAN.normalize(code) == code + "6"
+    assert JAN.validate(code) is None
 
     # Check if the checksum digit is calculated correctly
     # The check digit should be `1`
@@ -154,11 +166,8 @@ def test_jan():
     barcode = JAN(code)
     # The check digit is calculated when instansiating
     assert barcode == "4506381333936"
-    try:
-        code = "1"
-        barcode = JAN(code)
-    except IncorrectFormat:
-        pass
+    with pytest.raises(IncorrectFormat):
+        JAN("1")
 
     # Check if guards are in the correct positions
     binary_string = barcode.get_binary_string
@@ -168,3 +177,12 @@ def test_jan():
     assert left_guard == "101"
     assert right_guard == "101"
     assert center_guard == "01010"
+
+    with pytest.raises(IncorrectFormat):
+        JAN.validate("120638133393")
+
+
+@pytest.mark.parametrize("barcode_type", [EAN8, EAN13, EAN14])
+def test_ean_calculate_checksum_rejects_non_digits(barcode_type):
+    with pytest.raises(IncorrectFormat):
+        barcode_type.calculate_checksum("x" * barcode_type.BARCODE_LENGTH)

pybarcodes-1.2.2/tests/test_images.py

@@ -0,0 +1,101 @@
+from io import BytesIO
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+from pybarcodes import CODE39, EAN13
+
+
+def assert_barcode_image(image: Image.Image) -> None:
+    assert image.mode == "RGB"
+    assert image.width > 0
+    assert image.height > 0
+    assert image.getbbox() == (0, 0, image.width, image.height)
+
+
+def test_ean_image_generation_and_save(tmp_path: Path):
+    barcode = EAN13("400638133393")
+
+    image = barcode.render()
+    assert_barcode_image(image)
+    assert_barcode_image(barcode.image)
+
+    output_path = tmp_path / "ean13.png"
+    saved_image = barcode.save(
+        str(output_path), module_width=3, bar_height=80, quiet_zone=20, draw_text=False
+    )
+
+    assert output_path.exists()
+    assert saved_image.size == (len(barcode.get_binary_string) * 3 + 40, 80)
+    with Image.open(output_path) as image_file:
+        assert image_file.size == saved_image.size
+        assert image_file.mode == "RGB"
+
+
+def test_code39_image_generation():
+    barcode = CODE39("ABC123")
+
+    image = barcode.image
+
+    assert_barcode_image(image)
+
+
+def test_renderer_controls():
+    barcode = EAN13("400638133393")
+
+    image = barcode.render(
+        module_width=4,
+        bar_height=120,
+        quiet_zone=12,
+        font_size=16,
+        draw_text=False,
+    )
+
+    assert image.size == (len(barcode.get_binary_string) * 4 + 24, 120)
+
+
+def test_renderer_rejects_invalid_controls():
+    barcode = EAN13("400638133393")
+
+    with pytest.raises(ValueError):
+        barcode.render(module_width=0)
+    with pytest.raises(ValueError):
+        barcode.render(bar_height=0)
+    with pytest.raises(ValueError):
+        barcode.render(quiet_zone=0)
+    with pytest.raises(ValueError):
+        barcode.render(font_size=0)
+
+
+def test_text_outputs(tmp_path: Path):
+    barcode = EAN13("400638133393")
+
+    output_path = tmp_path / "ean13.txt"
+    barcode.write(str(output_path))
+
+    assert output_path.read_text() == "4006381333931"
+    assert barcode.to_text_bytes() == b"4006381333931"
+    assert isinstance(barcode.to_text_bytesio(), BytesIO)
+    assert barcode.to_text_bytesio().read() == b"4006381333931"
+    assert isinstance(barcode.to_bytesio(), BytesIO)
+    assert barcode.to_bytesio().read() == b"4006381333931"
+    assert str(barcode) == "<EAN13(code=4006381333931)>"
+    assert repr(barcode) == "<EAN13(code=4006381333931)>"
+
+
+def test_image_bytes_outputs():
+    barcode = EAN13("400638133393")
+
+    image_bytes = barcode.to_image_bytes(
+        module_width=3, bar_height=80, quiet_zone=20, draw_text=False
+    )
+    assert image_bytes.startswith(b"\x89PNG")
+
+    image_buffer = barcode.to_image_bytesio(
+        module_width=3, bar_height=80, quiet_zone=20, draw_text=False
+    )
+    assert isinstance(image_buffer, BytesIO)
+    with Image.open(image_buffer) as image_file:
+        assert image_file.size == (len(barcode.get_binary_string) * 3 + 40, 80)
+        assert image_file.mode == "RGB"

pybarcodes-1.2.2/tests/test_spec_fixtures.py

@@ -0,0 +1,55 @@
+import pytest
+
+from pybarcodes import CODE39, EAN8, EAN13, EAN14
+
+
+# GS1 check digit algorithm reference:
+# https://www.gs1.org/services/how-calculate-check-digit-manually
+@pytest.mark.parametrize(
+    ("barcode_type", "payload", "expected_code"),
+    [
+        (EAN8, "9638507", "96385074"),
+        (EAN13, "629104150021", "6291041500213"),
+        (EAN14, "1061414145678", "10614141456786"),
+    ],
+)
+def test_gs1_check_digit_fixtures(barcode_type, payload, expected_code):
+    assert barcode_type.normalize(payload) == expected_code
+    assert barcode_type(payload).code == expected_code
+
+
+def test_ean8_binary_pattern_fixture():
+    barcode = EAN8("9638507")
+
+    assert barcode.get_binary_string == (
+        "1010001011010111101111010110111010101001110111001010001001011100101"
+    )
+
+
+def test_ean13_binary_pattern_fixture():
+    barcode = EAN13("629104150021")
+
+    assert barcode.get_binary_string == (
+        "101"
+        "0010011"
+        "0010111"
+        "0110011"
+        "0100111"
+        "0100011"
+        "0011001"
+        "01010"
+        "1001110"
+        "1110010"
+        "1110010"
+        "1101100"
+        "1100110"
+        "1000010"
+        "101"
+    )
+
+
+# Code 39 MOD43 reference:
+# https://docshield.tungstenautomation.com/ControlSuite/en_US/1.5.0-uh5vow9jo0/help/QCP/Dita/ACSCChecksum.html
+def test_code39_mod43_check_digit_fixture():
+    assert CODE39.normalize("+1110001111") == "+11100011115"
+    assert CODE39("+1110001111").calculate_checksum("+1110001111") == 5

pybarcodes-1.0.3/pybarcodes/barcode.py

@@ -1,159 +0,0 @@
-from collections import namedtuple
-from io import BytesIO
-from pathlib import Path
-from typing import Union
-
-from PIL import Image, ImageDraw, ImageFont
-
-
-class Barcode:
-    """A base class for all barcode types"""
-
-    def __init__(self, barcode: Union[str, int]):
-        self.code = str(barcode)
-
-    @property
-    def image(self) -> Image.Image:
-        """Retrieves and returns the PIL.Image object with the barcode
-
-        Returns
-        -------
-        PIl.Image.Image:
-            The barcode image
-        """
-
-        return self._get_barcode_image()
-
-    def save(self, path: str, size: tuple = None) -> Image.Image:
-        """Create a PIL Image object and save it to the path given.
-
-        It also returns that image object to the caller.
-
-        Parameters
-        ----------
-        path: str
-            The path to save the image to
-
-        Returns
-        -------
-        Returns a PIL Image object to the caller
-        """
-
-        img = self._get_barcode_image()
-
-        if size is not None:
-            img = img.resize(size)
-        img.save(path)
-
-    def show(self) -> None:
-        """Shows the barcode image"""
-
-        img = self._get_barcode_image()
-        img.show()
-
-    def to_bytesio(self) -> BytesIO:
-        """
-        Write the barcode to a BytesIO object
-
-        Returns
-        -------
-        Returns the BytesIO object created
-        """
-
-        obj = BytesIO()
-        obj.write(self.code.encode("ascii"))
-        obj.seek(0)
-        return obj
-
-    def write(self, path: str) -> None:
-        """
-        Tries to save the barcode to a text file
-
-        Parameters
-        ----------
-        path: str
-            The path of the file
-        """
-        with open(path, "w") as file:
-            file.write(self.code)
-
-    def _get_barcode_image(self) -> Image.Image:
-        """Creates a PIL Image from the binary string of the barcode
-
-        Returns
-        -------
-        A PIL Image with the barcode is returned to the caller.
-        """
-
-        # Get the padding around the barcode
-        padding = self.BARCODE_PADDING
-
-        # Get the final image's width and height
-        selected_size, font_size = self.BARCODE_SIZE, self.BARCODE_FONT_SIZE
-
-        # This is for the white space around the barcode
-        padded_size = (
-            selected_size[0] + padding.width,
-            selected_size[1] + padding.height,
-        )
-
-        # Get each column's width and height
-        column_size = self._get_column_size()
-
-        # Create a white base image to write columns
-        base = Image.new("RGB", padded_size, (255, 255, 255))
-
-        # Create the image for the barcode
-        img = Image.new(
-            "RGB",
-            (column_size * self.BARCODE_COLUMN_NUMBER, selected_size[1]),
-            (255, 255, 255),
-        )
-
-        # Get the binary string representation of the barcode digits
-        binary_string = self.get_binary_string
-
-        index = 0
-        for digit in binary_string:
-            color = (0, 0, 0) if digit == "1" else (255, 255, 255)
-            column = Image.new("RGB", (column_size, img.height), color)
-            img.paste(column, (index, 0))
-            index += column_size
-
-        # Crop redundant whitespace after barcode
-        img = img.crop((0, 0, index, img.height))
-
-        # Paste the barcode on the center of the padded base
-        Point = namedtuple("Point", "x y")
-        base_center = Point(base.width // 2, base.height // 2)
-        img_center = Point(img.width // 2, img.height // 2)
-
-        base.paste(img, (base_center.x - img_center.x, base_center.y - img_center.y))
-
-        # Write the digits at the bottom
-        cwd = Path(__file__).parent
-        font_path = str(cwd.joinpath(cwd, "fonts", "arial.ttf"))
-
-        draw = ImageDraw.Draw(base)
-        font = ImageFont.truetype(font_path, font_size)
-
-        text_width = draw.textlength(self.code, font)
-        x = base_center.x - text_width // 2
-        y = base.height - (base.height - img.height) // 2
-
-        draw.text((x, y), self.code, (0, 0, 0), font=font)
-        return base
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return self.code == other.code
-        elif isinstance(other, str):
-            return self.code == other
-
-        return False
-
-    def __str__(self) -> str:
-        return f"<{self.__class__.__name__}(code={self.code})>"
-
-    def __repr__(self):
-        return self.__str__()