pybarcodes 1.0.2__tar.gz → 1.2.1__tar.gz

{pybarcodes-1.0.2 → pybarcodes-1.2.1}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: pybarcodes
-Version: 1.0.2
+Version: 1.2.1
 Summary: A Python package for barcode generation
+Author-email: atbuy <buy@atbuy.dev>
 License-Expression: MIT
-License-File: LICENSE
+Project-URL: Homepage, https://github.com/atbuy/pybarcodes
+Project-URL: Repository, https://github.com/atbuy/pybarcodes
+Project-URL: Bug Tracker, https://github.com/atbuy/pybarcodes/issues
+Project-URL: Source Code, https://github.com/atbuy/pybarcodes
+Project-URL: CI/CD, https://github.com/atbuy/pybarcodes/actions
 Keywords: barcode,scanner,generator,ean13,code39,jan,python
-Author: atbuy
-Author-email: buy@atbuy.dev
-Requires-Python: >=3.10
 Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
@@ -23,13 +24,11 @@ Classifier: Topic :: Multimedia :: Graphics
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Requires-Dist: pillow (>8,<13)
-Project-URL: Bug Tracker, https://github.com/atbuy/pybarcodes/issues
-Project-URL: CI/CD, https://github.com/atbuy/pybarcodes/actions
-Project-URL: Homepage, https://github.com/atbuy/pybarcodes
-Project-URL: Repository, https://github.com/atbuy/pybarcodes
-Project-URL: Source Code, https://github.com/atbuy/pybarcodes
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: pillow<13,>8
+Dynamic: license-file
 
 pybarcodes
 ==========
@@ -49,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.
 
@@ -70,7 +69,7 @@ PRs are welcome :)
 Installing
 -----------
 
-**Python 3.9 or higher is required**
+**Python 3.10 or higher is required**
 
 To install the library you can run the following command:
 
@@ -134,4 +133,3 @@ Links
 
 - `Documentation <https://pybarcodes.readthedocs.io/en/latest/index.html>`_
 - `PyPi <https://pypi.org/project/pybarcodes/>`_
-

{pybarcodes-1.0.2 → pybarcodes-1.2.1}/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.
 
@@ -37,7 +37,7 @@ PRs are welcome :)
 Installing
 -----------
 
-**Python 3.9 or higher is required**
+**Python 3.10 or higher is required**
 
 To install the library you can run the following command:
 

{pybarcodes-1.0.2 → pybarcodes-1.2.1}/pybarcodes/__init__.py

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

pybarcodes-1.2.1/pybarcodes/barcode.py

@@ -0,0 +1,311 @@
+from collections import namedtuple
+from io import BytesIO
+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 = self.normalize(barcode)
+
+    @classmethod
+    def validate(cls, barcode: Union[str, int]) -> None:
+        """Validate barcode input."""
+
+    @classmethod
+    def normalize(cls, barcode: Union[str, int]) -> 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: tuple = None,
+        module_width: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: 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: str,
+        size: tuple = None,
+        module_width: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: int = None,
+        draw_text: bool = True,
+        **save_kwargs,
+    ) -> 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: tuple = None,
+        module_width: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: int = None,
+        draw_text: bool = True,
+        **save_kwargs,
+    ) -> 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: tuple = None,
+        module_width: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: int = None,
+        draw_text: bool = True,
+        **save_kwargs,
+    ) -> 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: str, 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: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: int = None,
+        draw_text: bool = True,
+    ):
+        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: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: 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):
+        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__()

{pybarcodes-1.0.2 → pybarcodes-1.2.1}/pybarcodes/codes.py

@@ -1,8 +1,7 @@
 from collections import namedtuple
-from pathlib import Path
 from typing import Union
 
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw
 
 from .barcode import Barcode
 from .codings import codex as CODEXCoding
@@ -15,7 +14,7 @@ class Code(Barcode):
     def __init__(self, barcode: Union[str, int]):
         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: Union[str, int]) -> 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: Union[str, int]) -> 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.
@@ -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: int = None,
+        bar_height: int = None,
+        quiet_zone: int = None,
+        font_size: 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