fix: allow comi.number to be a float

Bump actions/checkout from 5 to 6

.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Tests
+
+on: [ push, pull_request ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [ "3.8", "3.9", "3.10", "3.11", "3.12", "3.13" ]
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install poetry
+          poetry install --no-interaction --no-root --with dev
+
+      - name: Run tests with pytest
+        run: |
+          poetry run pytest tests/ -v --cov=cbz --cov-report=xml --cov-report=term-missing

.gitignore

@@ -173,4 +173,5 @@ pyrightconfig.json
 ### CBZ ###
 *.cbz
 *.pdf
-*.zip
+*.zip
+*cbr

CHANGELOG.md

@@ -4,6 +4,67 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.4.5] - 2025-10-19
+
+### Changed
+
+- More flexible suffix checking to support complex archive paths.
+- Improved validation in `PageInfo.load()` to handle empty or invalid data correctly.
+
+## [3.4.4] - 2025-09-21
+
+### Added
+
+- Added `[pillow]` extension to support `.jxl` and `.avif` images.
+
+### Fixed
+
+- Files in the input archives are now sorted alphabetically.
+
+## [3.4.3] - 2025-08-31
+
+### Changed
+
+- Bump actions/checkout from 4 to 5.
+
+### Fixed
+
+- Fix ComicInfo XML parsing for single page comic.
+
+## [3.4.2] - 2025-07-26
+
+### Added
+
+- Adding CI tests.
+
+## [3.4.1] - 2025-07-11
+
+### Fixed
+
+- Fix installation instructions.
+
+## [3.4.0] - 2025-07-09
+
+### Added
+
+- Support for PDF files.
+- Support for CBR (Comic Book RAR) files.
+
+### Changed
+
+- Replaced `PyMuPDF` with `pypdf` for PDF handling.
+- Updated third-party license documentation for bundled libraries.
+
+### New Contributors
+
+- [tssujt](https://github.com/tssujt)
+
+## [3.3.7] - 2025-01-04
+
+### Fixed
+
+- Import error on Unix systems for the comic player.
+
 ## [3.3.6] - 2024-12-22
 
 ### Added
@@ -171,6 +232,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - Initial release.
 
+[3.4.5]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.5
+[3.4.4]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.4
+[3.4.3]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.3
+[3.4.2]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.2
+[3.4.1]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.1
+[3.4.0]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.0
+[3.3.7]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.7
 [3.3.6]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.6
 [3.3.5]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.5
 [3.3.4]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.4

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 hyugogirubato
+Copyright (c) 2025 hyugogirubato
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,6 +1,6 @@
 # CBZ
 
-CBZ is a Python library designed for creating, manipulating, and viewing comic book files in CBZ format. It offers a straightforward interface to pack comic pages into CBZ archives, extract metadata, and display comics using a built-in player.
+CBZ is a Python library designed for creating, manipulating, and viewing comic book files in CBZ, CBR, and PDF formats. It offers a straightforward interface to pack comic pages into CBZ archives, extract metadata from CBZ and CBR files, and display comics using a built-in player.
 
 ## Features
 
@@ -8,13 +8,14 @@ CBZ is a Python library designed for creating, manipulating, and viewing comic b
 - 📚 Pack images into CBZ format for comics and manga
 - 📝 Extract and manage title, series, format, and more
 - 🖼️ Handle comic pages with attributes like type and format
-- 📦 Unpack CBZ files to retrieve comic information
-- 🛠️ Built-in player for viewing CBZ comics
+- 📦 Unpack CBZ and CBR files to retrieve comic information, or extract images from PDF files
+- 🛠️ Built-in player for viewing CBZ, CBR, and PDF comics
+- 📚 Full CBR (RAR) format support for reading existing archives
 - ❤️ Fully Open-Source! Pull Requests Welcome
 
 ## Installation
 
-Install KeyDive from PyPI using Poetry:
+Install CBZ from PyPI using pip:
 
 ```shell
 pip install cbz
@@ -73,7 +74,15 @@ if __name__ == '__main__':
 
 ## Player
 
-CBZ includes a command-line player for viewing CBZ comic book files. Simply run cbzplayer <file> to launch the player with the specified CBZ file.
+CBZ includes a command-line player for viewing comic book files in multiple formats. Simply run `cbzplayer <file>` to launch the player with the specified comic book file.
+
+### Supported Formats
+
+- **CBZ** (Comic Book ZIP) - Standard ZIP archives containing images and metadata
+- **CBR** (Comic Book RAR) - RAR archives containing images and metadata
+- **PDF** - Portable Document Format files with embedded images (images only, no metadata)
+
+### Usage
 
 ````shell
 usage: cbzplayer [-h] <file>
@@ -81,13 +90,37 @@ usage: cbzplayer [-h] <file>
 Launch CBZ player with a comic book file
 
 positional arguments:
-  <file>      Path to the CBZ comic book file.
+  <file>      Path to the CBZ, CBR, or PDF comic book file.
 
 options:
   -h, --help  show this help message and exit
-
 ````
 
+### Examples
+
+```shell
+# View a CBZ file
+cbzplayer my_comic.cbz
+
+# View a CBR file
+cbzplayer my_comic.cbr
+
+# View a PDF file
+cbzplayer my_comic.pdf
+```
+
+### Requirements for CBR Support
+
+CBR file support requires:
+
+- The `rarfile` Python package (automatically installed with CBZ)
+- An external RAR extraction tool such as:
+    - `unrar` (recommended) - Available in most package managers
+    - `rar` - Commercial RAR archiver
+    - `7zip` - Free alternative with RAR support
+
+For installation instructions and compatibility details, see the [rarfile documentation](https://github.com/markokr/rarfile).
+
 ## Detailed Usage
 
 ### Creating a ComicInfo Object
@@ -96,6 +129,7 @@ The `ComicInfo` class represents a comic book with metadata and pages. It suppor
 
 ```python
 from cbz.comic import ComicInfo
+from cbz.constants import PageType, YesNo, Manga, AgeRating, Format
 from cbz.page import PageInfo
 
 # Example usage:
@@ -135,30 +169,59 @@ Pack the comic into a CBZ file format:
 cbz_content = comic.pack()
 ```
 
-### Unpacking from CBZ
+### Loading from Different Formats
 
-Load a comic from an existing CBZ file:
+Load a comic from an existing CBZ file (with metadata):
 
 ```python
 comic_from_cbz = ComicInfo.from_cbz('/path/to/your_comic.cbz')
 ```
 
+Load a comic from an existing CBR file (with metadata):
+
+```python
+comic_from_cbr = ComicInfo.from_cbr('/path/to/your_comic.cbr')
+```
+
+Load a comic from a PDF file (images only, no metadata):
+
+```python
+comic_from_pdf = ComicInfo.from_pdf('/path/to/your_comic.pdf')
+```
+
+**Notes**:
+
+- CBR support requires an external RAR extraction tool. For detailed compatibility information and advanced configuration, see the [rarfile documentation](https://github.com/markokr/rarfile).
+- PDF files only provide image content; comic metadata (title, series, etc.) is not available from PDF files.
+
 ## Contributors
 
 <a href="https://github.com/hyugogirubato"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/65763543?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="hyugogirubato"/></a>
 <a href="https://github.com/piskunqa"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/38443069?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="piskunqa"/></a>
 <a href="https://github.com/OleskiiPyskun"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/75667382?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="OleskiiPyskun"/></a>
+<a href="https://github.com/tssujt"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/17313425?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="tssujt"/></a>
+<a href="https://github.com/gokender"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/3709740?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="gokender"/></a>
 <a href="https://github.com/domenicoblanco"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/9018104?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="domenicoblanco"/></a>
 <a href="https://github.com/RivMt"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/40086827?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="RivMt"/></a>
 <a href="https://github.com/flolep2607"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/24566964?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="flolep2607"/></a>
-<a href="https://github.com/gokender"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/3709740?v=4&h=25&w=25&fit=cover&mask=circle&maxage=7d" alt="gokender"/></a>
-
 
 ## Licensing
 
-This software is licensed under the terms of [MIT License](https://github.com/hyugogirubato/cbz/blob/main/LICENSE).  
+This software is licensed under the terms of [MIT License](https://github.com/hyugogirubato/cbz/blob/main/LICENSE).
 You can find a copy of the license in the LICENSE file in the root folder.
 
-* * * 
+### Third-Party Licenses
 
-© hyugogirubato 2024
+This project uses the following third-party libraries:
+
+- **[langcodes](https://pypi.org/project/langcodes/)** - MIT License
+- **[Pillow](https://pypi.org/project/Pillow/)** - HPND License
+- **[pillow-avif-plugin](https://pypi.org/project/pillow-avif-plugin/)** - MIT License
+- **[pillow-jxl-plugin](https://pypi.org/project/pillow-jxl-plugin/)** - MIT License
+- **[pypdf](https://pypi.org/project/pypdf/)** - BSD License
+- **[rarfile](https://pypi.org/project/rarfile/)** - ISC License
+- **[xmltodict](https://pypi.org/project/xmltodict/)** - MIT License
+
+---
+
+© hyugogirubato 2025

cbz/__init__.py

@@ -1,2 +1,9 @@
 from .comic import ComicInfo
 from .page import PageInfo
+
+# Register optional Pillow plugins
+for _plugin in ('pillow_avif', 'pillow_jxl'):
+    try:
+        __import__(_plugin)
+    except ImportError:
+        pass

cbz/__main__.py

@@ -8,7 +8,7 @@ from cbz.comic import ComicInfo
 def main() -> None:
     # Parse command-line arguments
     parser = argparse.ArgumentParser(description='Launch CBZ player with a comic book file')
-    parser.add_argument('comic_path', type=Path, metavar='<file>', help='Path to the CBZ comic book file.')
+    parser.add_argument('comic_path', type=Path, metavar='<file>', help='Path to the CBZ, CBR, or PDF comic book file.')
     args = parser.parse_args()
 
     # Validate the provided path
@@ -17,9 +17,15 @@ def main() -> None:
         print(f'Error: The file "{comic_path}" does not exist or is not a valid file.')
         exit(1)
 
-    # Create ComicInfo object from CBZ file
+    # Create ComicInfo object from comic file
     try:
-        comic_info = ComicInfo.from_pdf(comic_path) if comic_path.suffix == '.pdf' else ComicInfo.from_cbz(comic_path)
+        if comic_path.suffix == '.pdf':
+            comic_info = ComicInfo.from_pdf(comic_path)
+        elif comic_path.suffix == '.cbr':
+            comic_info = ComicInfo.from_cbr(comic_path)
+        else:
+            comic_info = ComicInfo.from_cbz(comic_path)
+
         # Launch the CBZ player
         comic_info.show()
     except Exception as e:

cbz/comic.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
+import logging
 import zipfile
 
 from datetime import datetime, timezone
 from enum import Enum
 from io import BytesIO
-from typing import Union
+from typing import Union, List
 from pathlib import Path
 
-import fitz
+import rarfile
 import xmltodict
 
+from pypdf import PdfReader
+
 from cbz.constants import XML_NAME, COMIC_FIELDS, IMAGE_FORMAT, PAGE_FIELDS
 from cbz.models import ComicModel
 from cbz.page import PageInfo
@@ -22,27 +25,27 @@ class ComicInfo(ComicModel):
     ComicInfo class that represents the comic book information and pages.
     """
 
-    def __init__(self, pages: list[PageInfo], **kwargs):
+    def __init__(self, pages: List[PageInfo], **kwargs):
         """
         Initialize the ComicInfo instance with pages and additional attributes.
 
         Args:
-            pages (list[PageInfo]): List of PageInfo objects representing the comic pages.
+            pages (List[PageInfo]): List of PageInfo objects representing the comic pages.
             **kwargs: Additional attributes for the comic.
 
         Attributes:
-            pages (list[PageInfo]): Stores the comic pages.
+            pages (List[PageInfo]): Stores the comic pages.
         """
         super(ComicInfo, self).__init__(**kwargs)
         self.pages = pages
 
     @classmethod
-    def from_pages(cls, pages: list[PageInfo], **kwargs) -> ComicInfo:
+    def from_pages(cls, pages: List[PageInfo], **kwargs) -> ComicInfo:
         """
         Create a ComicInfo instance from pages and additional attributes.
 
         Args:
-            pages (list[PageInfo]): List of PageInfo objects representing the comic pages.
+            pages (List[PageInfo]): List of PageInfo objects representing the comic pages.
             **kwargs: Additional attributes for the comic.
 
         Returns:
@@ -66,7 +69,25 @@ class ComicInfo(ComicModel):
         """
         if not isinstance(path, (Path, str)):
             raise ValueError(f'Expecting Path object or path string, got {path!r}')
-        return cls.__unpack_zip(path)
+        return cls.__unpack_zip(Path(path))
+
+    @classmethod
+    def from_cbr(cls, path: Union[Path, str]) -> ComicInfo:
+        """
+        Create a ComicInfo instance from a CBR file.
+
+        Args:
+            path (Union[Path, str]): Path to the CBR file.
+
+        Returns:
+            ComicInfo: An instance of ComicInfo.
+
+        Raises:
+            ValueError: If the provided path is not a Path object or a string.
+        """
+        if not isinstance(path, (Path, str)):
+            raise ValueError(f'Expecting Path object or path string, got {path!r}')
+        return cls.__unpack_rar(Path(path))
 
     @classmethod
     def from_pdf(cls, path: Union[Path, str]) -> ComicInfo:
@@ -84,7 +105,7 @@ class ComicInfo(ComicModel):
         """
         if not isinstance(path, (Path, str)):
             raise ValueError(f'Expecting Path object or path string, got {path!r}')
-        return cls.__unpack_pdf(path)
+        return cls.__unpack_pdf(Path(path))
 
     @staticmethod
     def __unpack_pdf(path: Path) -> ComicInfo:
@@ -97,18 +118,94 @@ class ComicInfo(ComicModel):
         Returns:
             ComicInfo: An instance of ComicInfo.
         """
-        pages: list[PageInfo] = []
-        with fitz.open(path) as pf:
-            for element in pf:
-                # Check if the page has images
-                images = element.get_images(full=True)
-                for i, image in enumerate(images):
-                    base = pf.extract_image(image[0])
-                    pages.append(PageInfo.loads(data=base['image']))
+        pages: List[PageInfo] = []
+        reader = PdfReader(path)
+        for page in reader.pages:
+            for image in page.images:
+                pages.append(PageInfo.loads(data=image.data))
 
         assert pages, 'No valid images present in file'
         return ComicInfo.from_pages(pages=pages)
 
+    @staticmethod
+    def __extract_info(items: dict, fields: dict) -> dict:
+        """
+        Extract and convert field information from the provided items and fields.
+
+        Args:
+            items (dict): Dictionary containing item attributes.
+            fields (dict): Dictionary containing field mappings and types.
+
+        Returns:
+            dict: Dictionary with extracted and converted field information.
+        """
+        content = {}
+        for key, (field_key, field_type) in fields.items():
+            if field_key in items:
+                content[key] = field_type(items[field_key])
+        return content
+
+    @staticmethod
+    def __process_archive(archive_file: Union[zipfile.ZipFile, rarfile.RarFile]) -> ComicInfo:
+        """
+        Common logic for processing archive files (CBZ/CBR).
+
+        Args:
+            archive_file (Union[ZipFile, RarFile]): Archive file object (ZipFile or RarFile)
+
+        Returns:
+            ComicInfo: An instance of ComicInfo.
+        """
+        pages = []
+        names = sorted(archive_file.namelist())
+        comic_info = {}
+
+        if XML_NAME in names:
+            with archive_file.open(XML_NAME, 'r') as f:
+                comic_info = xmltodict.parse(f.read(), force_list=('Page',)).get('ComicInfo', {})
+            names.remove(XML_NAME)
+
+        comic = ComicInfo.__extract_info(
+            items=comic_info,
+            fields=COMIC_FIELDS
+        )
+
+        pages_info = comic_info.get('Pages', {}).get('Page', [])
+        for i, name in enumerate(names):
+            suffix = Path(name).suffix
+
+            # Some archives may contain folders or hidden files (e.g., ".extra/" or "__MACOSX/.DS_Store")
+            # that could corrupt the suffix detection and cause invalid image handling.
+            if suffix not in IMAGE_FORMAT:
+                logging.warning(f'Skipping unsupported or invalid file: {name!r} (suffix={suffix!r})')
+                continue
+
+            with archive_file.open(name, 'r') as f:
+                page_info = {}
+                if i < len(pages_info):
+                    page_info = ComicInfo.__extract_info(
+                        items=pages_info[i],
+                        fields=PAGE_FIELDS
+                    )
+                page_info['name'] = Path(name).name
+                pages.append(PageInfo.loads(data=f.read(), **page_info))
+
+        return ComicInfo.from_pages(pages=pages, **comic)
+
+    @staticmethod
+    def __unpack_rar(path: Path) -> ComicInfo:
+        """
+        Unpack a CBR file and create a ComicInfo instance.
+
+        Args:
+            path (Path): Path to the CBR file.
+
+        Returns:
+            ComicInfo: An instance of ComicInfo.
+        """
+        with rarfile.RarFile(path, 'r') as rf:
+            return ComicInfo.__process_archive(rf)
+
     @staticmethod
     def __unpack_zip(path: Path) -> ComicInfo:
         """
@@ -120,56 +217,8 @@ class ComicInfo(ComicModel):
         Returns:
             ComicInfo: An instance of ComicInfo.
         """
-
-        def __info(items: dict, fields: dict) -> dict:
-            """
-            Extract and convert field information from the provided items and fields.
-
-            Args:
-                items (dict): Dictionary containing item attributes.
-                fields (dict): Dictionary containing field mappings and types.
-
-            Returns:
-                dict: Dictionary with extracted and converted field information.
-            """
-            content = {}
-            for key, (field_key, field_type) in fields.items():
-                if field_key in items:
-                    content[key] = field_type(items[field_key])
-            return content
-
-        pages = []
-
         with zipfile.ZipFile(path, 'r', zipfile.ZIP_STORED) as zf:
-            names = zf.namelist()
-            comic_info = {}
-
-            if XML_NAME in names:
-                with zf.open(XML_NAME, 'r') as f:
-                    comic_info = xmltodict.parse(f.read()).get('ComicInfo', {})
-                names.remove(XML_NAME)
-
-            comic = __info(
-                items=comic_info,
-                fields=COMIC_FIELDS
-            )
-
-            pages_info = comic_info.get('Pages', {}).get('Page', [])
-            for i, name in enumerate(names):
-                suffix = Path(name).suffix
-                if suffix:
-                    assert suffix in IMAGE_FORMAT, f'Unsupported image format: {suffix}'
-                    with zf.open(name, 'r') as f:
-                        page_info = {}
-                        if i < len(pages_info):
-                            page_info = __info(
-                                items=pages_info[i],
-                                fields=PAGE_FIELDS
-                            )
-                        page_info['name'] = Path(f.name).name
-                        pages.append(PageInfo.loads(data=f.read(), **page_info))
-
-        return ComicInfo.from_pages(pages=pages, **comic)
+            return ComicInfo.__process_archive(zf)
 
     def get_info(self) -> dict:
         """

cbz/constants.py

@@ -3,189 +3,195 @@ from typing import Union
 
 from langcodes import Language
 
-XML_NAME = 'ComicInfo.xml'
+XML_NAME = "ComicInfo.xml"
 IMAGE_FORMAT = {
-    '.jpeg', '.jpg',  # Joint Photographic Experts Group
-    '.png',  # Portable Network Graphics
-    '.gif',  # Graphics Interchange Format
-    '.bmp',  # Bitmap Image File
-    '.tiff', '.tif',  # Tagged Image File Format
-    '.webp'  # Web Picture Format
+    ".jpeg",
+    ".jpg",  # JPEG (Joint Photographic Experts Group)
+    ".png",  # PNG (Portable Network Graphics)
+    ".gif",  # GIF (Graphics Interchange Format)
+    ".bmp",  # BMP (Bitmap Image File)
+    ".tiff",
+    ".tif",  # TIFF (Tagged Image File Format)
+    ".webp",  # WebP (Web Picture Format, by Google)
+    ".jxl",  # JPEG XL (Next-generation JPEG format)
+    ".avif",  # AVIF (AV1 Image File Format, based on AV1 codec)
 }
 
 
 class YesNo(Enum):
-    UNKNOWN = 'Unknown'
-    NO = 'No'
-    YES = 'Yes'
+    UNKNOWN = "Unknown"
+    NO = "No"
+    YES = "Yes"
 
 
 class Manga(Enum):
-    UNKNOWN = 'Unknown'
-    NO = 'No'
-    YES = 'Yes'
-    RIGHT_LEFT = 'YesAndRightToLeft'
+    UNKNOWN = "Unknown"
+    NO = "No"
+    YES = "Yes"
+    RIGHT_LEFT = "YesAndRightToLeft"
 
 
 class PageType(Enum):
-    FRONT_COVER = 'FrontCover'
-    INNER_COVER = 'InnerCover'
-    ROUNDUP = 'Roundup'
-    STORY = 'Story'
-    ADVERTISEMENT = 'Advertisement'
-    EDITORIAL = 'Editorial'
-    LETTERS = 'Letters'
-    PREVIEW = 'Preview'
-    BACK_COVER = 'BackCover'
-    OTHER = 'Other'
-    DELETED = 'Deleted'
+    FRONT_COVER = "FrontCover"
+    INNER_COVER = "InnerCover"
+    ROUNDUP = "Roundup"
+    STORY = "Story"
+    ADVERTISEMENT = "Advertisement"
+    EDITORIAL = "Editorial"
+    LETTERS = "Letters"
+    PREVIEW = "Preview"
+    BACK_COVER = "BackCover"
+    OTHER = "Other"
+    DELETED = "Deleted"
 
 
 class AgeRating(Enum):
-    UNKNOWN = 'Unknown'
-    ADULTS18 = 'Adults Only 18+'
-    CHILDHOOD = 'Early Childhood'
-    EVERYONE = 'Everyone'
-    EVERYONE10 = 'Everyone 10+'
-    G = 'G'
-    KIDS = 'Kids to Adults'
-    M = 'M'
-    MA15 = 'MA15+'
-    MATURE17 = 'Mature 17+'
-    PG = 'PG'
-    R18 = 'R18+'
-    PENDING = 'Rating Pending'
-    TEEN = 'Teen'
-    X18 = 'X18+'
+    UNKNOWN = "Unknown"
+    ADULTS18 = "Adults Only 18+"
+    CHILDHOOD = "Early Childhood"
+    EVERYONE = "Everyone"
+    EVERYONE10 = "Everyone 10+"
+    G = "G"
+    KIDS = "Kids to Adults"
+    M = "M"
+    MA15 = "MA15+"
+    MATURE17 = "Mature 17+"
+    PG = "PG"
+    R18 = "R18+"
+    PENDING = "Rating Pending"
+    TEEN = "Teen"
+    X18 = "X18+"
 
 
 class Format(Enum):
-    UNKNOWN = 'Unknown'
+    UNKNOWN = "Unknown"
     # ONE_SHOT = '1 Shot'
     # ONE_SHOT = '1/2',
     # ONE_SHOT = '1-Shot'
-    ANNOTATION = 'Annotation'
+    ANNOTATION = "Annotation"
     # ANNOTATIONS = 'Annotations'
-    ANNUAL = 'Annual'
-    ANTHOLOGY = 'Anthology'
+    ANNUAL = "Annual"
+    ANTHOLOGY = "Anthology"
     # BLACK_WHITE = 'B&W'
     # BLACK_WHITE = 'B/W'
     # BLACK_WHITE = 'B&&W'
-    BLACK_WHITE = 'Black & White'
+    BLACK_WHITE = "Black & White"
     # BOX_SET = 'Box Set'
-    BOX_SET = 'Box-Set'
-    CROSSOVER = 'Crossover'
-    DIRECTOR_CUT = 'Director\'s Cut'
-    EPILOGUE = 'Epilogue'
-    EVENT = 'Event'
-    FCBD = 'FCBD'
-    FLYER = 'Flyer'
+    BOX_SET = "Box-Set"
+    CROSSOVER = "Crossover"
+    DIRECTOR_CUT = "Director's Cut"
+    EPILOGUE = "Epilogue"
+    EVENT = "Event"
+    FCBD = "FCBD"
+    FLYER = "Flyer"
     # GIANT_SIZE = 'Giant'
     # GIANT_SIZE = 'Giant Size'
-    GIANT_SIZE = 'Giant-Size'
-    GRAPHIC_NOVEL = 'Graphic Novel'
+    GIANT_SIZE = "Giant-Size"
+    GRAPHIC_NOVEL = "Graphic Novel"
     # HARDCOVER = 'Hardcover'
-    HARDCOVER = 'Hard-Cover'
+    HARDCOVER = "Hard-Cover"
     # KING_SIZE = 'King'
     # KING_SIZE = 'King Size'
-    KING_SIZE = 'King-Size'
-    LIMITED_SERIES = 'Limited Series'
-    MAGAZINE = 'Magazine'
-    NSFW = 'NSFW'
+    KING_SIZE = "King-Size"
+    LIMITED_SERIES = "Limited Series"
+    MAGAZINE = "Magazine"
+    NSFW = "NSFW"
     # ONE_SHOT = 'One Shot'
-    ONE_SHOT = 'One-Shot'
-    POINT1 = 'Point 1'
-    PREVIEW = 'Preview'
-    PROLOGUE = 'Prologue'
-    REFERENCE = 'Reference'
-    REVIEW = 'Review'
-    REVIEWED = 'Reviewed'
-    SCANLATION = 'Scanlation'
-    SCRIPT = 'Script'
-    SERIES = 'Series'
-    SKETCH = 'Sketch'
-    SPECIAL = 'Special'
+    ONE_SHOT = "One-Shot"
+    POINT1 = "Point 1"
+    PREVIEW = "Preview"
+    PROLOGUE = "Prologue"
+    REFERENCE = "Reference"
+    REVIEW = "Review"
+    REVIEWED = "Reviewed"
+    SCANLATION = "Scanlation"
+    SCRIPT = "Script"
+    SERIES = "Series"
+    SKETCH = "Sketch"
+    SPECIAL = "Special"
     # TRADE_PAPER_BACK = 'TPB'
-    TRADE_PAPER_BACK = 'Trade Paper Back'
+    TRADE_PAPER_BACK = "Trade Paper Back"
     # WEB_COMIC = 'WebComic'
-    WEB_COMIC = 'Web Comic'
+    WEB_COMIC = "Web Comic"
     # YEAR_ONE = 'Year 1'
-    YEAR_ONE = 'Year One'
+    YEAR_ONE = "Year One"
 
 
 class Rating(float):
 
     def __new__(cls, value: Union[int, float] = -1) -> float:
-        assert -1 <= float(value) <= 5, f'Rating must be between 0 and 5, input {value}'
+        assert -1 <= float(value) <= 5, f"Rating must be between 0 and 5, input {value}"
         return super().__new__(cls, value)
 
 
 class LanguageISO(str):
 
-    def __new__(cls, value: str = '') -> str:
-        assert not value or Language.get(str(value)).is_valid(), f'Invalid {value} language'
+    def __new__(cls, value: str = "") -> str:
+        assert (
+            not value or Language.get(str(value)).is_valid()
+        ), f"Invalid {value} language"
         return super().__new__(cls, value)
 
 
 COMIC_FIELDS = {
-    'title': ('Title', str),
-    'series': ('Series', str),
-    'number': ('Number', int),
-    'count': ('Count', int),
-    'volume': ('Volume', int),
-    'alternate_series': ('AlternateSeries', str),
-    'alternate_number': ('AlternateNumber', int),
-    'alternate_count': ('AlternateCount', int),
-    'summary': ('Summary', str),
-    'notes': ('Notes', str),
-    'year': ('Year', int),
-    'month': ('Month', int),
-    'day': ('Day', int),
-    'writer': ('Writer', str),
-    'penciller': ('Penciller', str),
-    'inker': ('Inker', str),
-    'colorist': ('Colorist', str),
-    'letterer': ('Letterer', str),
-    'cover_artist': ('CoverArtist', str),
-    'editor': ('Editor', str),
-    'translator': ('Translator', str),
-    'publisher': ('Publisher', str),
-    'imprint': ('Imprint', str),
-    'genre': ('Genre', str),
-    'tags': ('Tags', str),
-    'web': ('Web', str),
-    'format': ('Format', Format),
-    'ean': ('EAN', str),
-    'black_white': ('BlackAndWhite', YesNo),
-    'manga': ('Manga', Manga),
-    'characters': ('Characters', str),
-    'teams': ('Teams', str),
-    'locations': ('Locations', str),
-    'scan_information': ('ScanInformation', str),
-    'story_arc': ('StoryArc', str),
-    'story_arc_number': ('StoryArcNumber', int),
-    'series_group': ('SeriesGroup', str),
-    'age_rating': ('AgeRating', AgeRating),
-    'main_character_or_team': ('MainCharacterOrTeam', str),
-    'review': ('Review', str),
-    'language_iso': ('LanguageISO', LanguageISO),
-    'community_rating': ('CommunityRating', Rating),
-    'added': ('Added', str),
-    'released': ('Released', str),
-    'file_size': ('FileSize', int),
-    'file_modified_time': ('FileModifiedTime', str),
-    'file_creation_time': ('FileCreationTime', str),
-    'book_price': ('BookPrice', str),
-    'custom_values_store': ('CustomValuesStore', str)
+    "title": ("Title", str),
+    "series": ("Series", str),
+    "number": ("Number", float),
+    "count": ("Count", int),
+    "volume": ("Volume", int),
+    "alternate_series": ("AlternateSeries", str),
+    "alternate_number": ("AlternateNumber", int),
+    "alternate_count": ("AlternateCount", int),
+    "summary": ("Summary", str),
+    "notes": ("Notes", str),
+    "year": ("Year", int),
+    "month": ("Month", int),
+    "day": ("Day", int),
+    "writer": ("Writer", str),
+    "penciller": ("Penciller", str),
+    "inker": ("Inker", str),
+    "colorist": ("Colorist", str),
+    "letterer": ("Letterer", str),
+    "cover_artist": ("CoverArtist", str),
+    "editor": ("Editor", str),
+    "translator": ("Translator", str),
+    "publisher": ("Publisher", str),
+    "imprint": ("Imprint", str),
+    "genre": ("Genre", str),
+    "tags": ("Tags", str),
+    "web": ("Web", str),
+    "format": ("Format", Format),
+    "ean": ("EAN", str),
+    "black_white": ("BlackAndWhite", YesNo),
+    "manga": ("Manga", Manga),
+    "characters": ("Characters", str),
+    "teams": ("Teams", str),
+    "locations": ("Locations", str),
+    "scan_information": ("ScanInformation", str),
+    "story_arc": ("StoryArc", str),
+    "story_arc_number": ("StoryArcNumber", int),
+    "series_group": ("SeriesGroup", str),
+    "age_rating": ("AgeRating", AgeRating),
+    "main_character_or_team": ("MainCharacterOrTeam", str),
+    "review": ("Review", str),
+    "language_iso": ("LanguageISO", LanguageISO),
+    "community_rating": ("CommunityRating", Rating),
+    "added": ("Added", str),
+    "released": ("Released", str),
+    "file_size": ("FileSize", int),
+    "file_modified_time": ("FileModifiedTime", str),
+    "file_creation_time": ("FileCreationTime", str),
+    "book_price": ("BookPrice", str),
+    "custom_values_store": ("CustomValuesStore", str),
 }
 
 PAGE_FIELDS = {
-    'image': ('@Image', int),
-    'type': ('@Type', PageType),
-    'double': ('@DoublePage', bool),
-    'key': ('@Key', str),
-    'bookmark': ('@Bookmark', str),
-    'image_size': ('@ImageSize', int),
-    'image_width': ('@ImageWidth', int),
-    'image_height': ('@ImageHeight', int)
+    "image": ("@Image", int),
+    "type": ("@Type", PageType),
+    "double": ("@DoublePage", bool),
+    "key": ("@Key", str),
+    "bookmark": ("@Bookmark", str),
+    "image_size": ("@ImageSize", int),
+    "image_width": ("@ImageWidth", int),
+    "image_height": ("@ImageHeight", int),
 }

cbz/models.py

@@ -1,5 +1,19 @@
-from cbz.constants import COMIC_FIELDS, PAGE_FIELDS, Format, YesNo, Manga, AgeRating, LanguageISO, Rating, PageType
+from cbz.constants import (
+    COMIC_FIELDS,
+    PAGE_FIELDS,
+    Format,
+    YesNo,
+    Manga,
+    AgeRating,
+    LanguageISO,
+    Rating,
+    PageType,
+)
 from cbz.utils import verify_attr, default_attr
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
 
 
 class BaseModel:
@@ -21,7 +35,7 @@ class BaseModel:
             # Set default values for each attribute based on its type
             setattr(self, key, kwargs.get(key, default_attr(field_type)))
 
-    def __setattr__(self, key: str, value: any) -> None:
+    def __setattr__(self, key: str, value: "Any") -> None:
         """
         Sets the value of an attribute and verifies its type.
 
@@ -39,6 +53,9 @@ class BaseModel:
                 value = field_type(value)
             # Verify that the assigned value matches the expected type
             verify_attr(field_type, key, value)
+            if isinstance(value, float):
+                if value.is_integer():
+                    value = int(value)
         except (AttributeError, KeyError):
             pass
         super().__setattr__(key, value)
@@ -50,9 +67,15 @@ class BaseModel:
         Returns:
             str: A string representation of the object, displaying its class name and attribute key-value pairs.
         """
-        return '{name}({items})'.format(
+        return "{name}({items})".format(
             name=self.__class__.__name__,
-            items=', '.join([f'{k}={repr(v)}' for k, v in self.__dict__.items() if not k.startswith('_')])
+            items=", ".join(
+                [
+                    f"{k}={repr(v)}"
+                    for k, v in self.__dict__.items()
+                    if not k.startswith("_")
+                ]
+            ),
         )
 
 
@@ -60,9 +83,10 @@ class ComicModel(BaseModel):
     """
     Model for representing comic book metadata.
     """
+
     title: str
     series: str
-    number: int
+    number: float
     count: int
     volume: int
     alternate_series: str
@@ -124,6 +148,7 @@ class PageModel(BaseModel):
     """
     Model for representing comic book pages.
     """
+
     type: PageType
     double: bool
     image_size: int

cbz/page.py

@@ -75,6 +75,8 @@ class PageInfo(PageModel):
             data = base64.b64decode(data)
         if not isinstance(data, bytes):
             raise ValueError(f'Expecting Bytes or Base64 input, got {data!r}')
+        if not data.strip():
+            raise ValueError(f'Empty or null data provided (length={len(data)})')
         return cls(data, **kwargs)
 
     @classmethod
@@ -98,7 +100,7 @@ class PageInfo(PageModel):
         path = Path(path)
         with path.open(mode='rb') as f:
             kwargs.setdefault('name', path.name)
-            return cls(f.read(), **kwargs)
+            return cls.loads(f.read(), **kwargs)
 
     def show(self) -> None:
         """

cbz/player.py

@@ -3,10 +3,13 @@ import tkinter as tk
 
 from io import BytesIO
 from tkinter import ttk
-from tkinter.constants import DISABLED, NORMAL
-from ctypes import windll
 from pathlib import Path
 
+try:
+    from ctypes import windll
+except ImportError:
+    windll = None  # windll is not available on this platform
+
 from PIL import Image, ImageTk
 
 from cbz.comic import ComicInfo
@@ -203,7 +206,7 @@ class Player:
         self.summary_text = tk.Text(self.canvas, wrap=tk.WORD, bg='white', bd=0, padx=10, pady=10)
         self.summary_text.tag_configure('bold', font=('Arial', 13, 'bold'))
         self.summary_text.tag_configure('normal', font=('Arial', 12), lmargin1=10, lmargin2=10)
-        self.summary_text.config(state=DISABLED)
+        self.summary_text.config(state=tk.DISABLED)
 
     def show_page(self) -> None:
         """
@@ -219,8 +222,8 @@ class Player:
             self._show_image_page()
 
         # Update navigation button states based on current page index
-        self.prev_button.config(state=DISABLED if self.current_page == -1 else NORMAL)
-        self.next_button.config(state=DISABLED if self.current_page + 1 == len(self.comic_info.pages) else NORMAL)
+        self.prev_button.config(state=tk.DISABLED if self.current_page == -1 else tk.NORMAL)
+        self.next_button.config(state=tk.DISABLED if self.current_page + 1 == len(self.comic_info.pages) else tk.NORMAL)
 
         # Update page index label text
         self.page_index_label.config(text=f'{self.current_page + 1}/{len(self.comic_info.pages)}')
@@ -235,7 +238,7 @@ class Player:
         # Display summary for the first page
         infos = self.comic_info.get_info()
 
-        self.summary_text.config(state=NORMAL)
+        self.summary_text.config(state=tk.NORMAL)
         self.summary_text.delete('1.0', tk.END)
 
         for key, value in infos.items():
@@ -245,7 +248,7 @@ class Player:
                 self.summary_text.insert(tk.END, f'{key}\n', 'bold')
                 self.summary_text.insert(tk.END, f'{value}\n\n', 'normal')
 
-        self.summary_text.config(state=DISABLED)
+        self.summary_text.config(state=tk.DISABLED)
         self.summary_text.place(relwidth=1, relheight=1)
 
     def _show_image_page(self) -> None:

cbz/utils.py

@@ -8,7 +8,7 @@ from PIL.IcoImagePlugin import IcoFile
 
 def default_attr(value: any) -> any:
     """
-    Provides a default value based on the expected type of an attribute.
+    Provides a default value based on the expected type of attribute.
 
     Args:
         value (any): Expected type or class of the attribute.

pyproject.toml

@@ -1,15 +1,20 @@
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry]
+[project]
 name = "cbz"
-version = "3.3.6"
-description = "CBZ simplifies creating, managing, and viewing comic book files in CBZ format, offering seamless packaging, metadata handling, and built-in viewing capabilities"
+version = "3.4.5"
+description = "CBZ simplifies creating, managing, and viewing comic book files in CBZ, CBR, and PDF formats, offering seamless packaging, metadata handling and built-in viewing capabilities."
 license = "MIT"
-authors = ["hyugogirubato <65763543+hyugogirubato@users.noreply.github.com>"]
+authors = [{name="hyugogirubato", email="65763543+hyugogirubato@users.noreply.github.com"}]
 readme = "README.md"
-keywords = ["python", "cbz", "ebooks", "manga", "comics", "webtoons"]
+keywords = [
+    "python",
+    "cbz",
+    "cbr",
+    "pdf",
+    "ebooks",
+    "manga",
+    "comics",
+    "webtoons",
+]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
@@ -17,32 +22,37 @@ classifiers = [
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Topic :: Utilities",
-    "Topic :: Software Development :: Libraries :: Python Modules"
+    "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-include = [
-    { path = "CHANGELOG.md", format = "sdist" },
-    { path = "README.md", format = "sdist" },
-    { path = "LICENSE", format = "sdist" }
+requires-python = ">=3.8,<4.0"
+
+dependencies= [
+"langcodes>=3.4.0",
+"Pillow>=10.4.0",
+"pypdf >=5.7.0",
+"rarfile>=4.2",
+"xmltodict>=0.14.2"
 ]
 
+
 [tool.poetry.urls]
 "Issues" = "https://github.com/hyugogirubato/cbz/issues"
 "Changelog" = "https://github.com/hyugogirubato/cbz/blob/main/CHANGELOG.md"
 
-[tool.poetry.dependencies]
-python = ">=3.8"
-xmltodict = ">=0.13.0"
-langcodes = ">=3.4.0"
-Pillow = ">=10.4.0"
-PyMuPDF = ">=1.24.7"
 
-[tool.poetry.scripts]
-cbzplayer = "cbz.__main__:main"
+[project.optional-dependencies]
+pillow = ["pillow-avif-plugin>=1.5.2", "pillow-jxl-plugin>=1.3.4"]
 
-[[tool.poetry.source]]
-name = "localpypi"
-url = "https://pypi.org/simple/"
-priority = "primary"
+[dependency-groups]
+dev = ["pytest>=7.4.0,<9.0.0", "pytest-cov>=5.0.0"]
+
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = [
+    "--cov=cbz",
+]
 
 [certificates]
-localpypi = { cert = false }
+localpypi = { cert = false }

tests/conftest.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+
+import pytest
+
+from cbz.comic import ComicInfo
+from cbz.page import PageInfo
+from cbz.constants import PageType
+
+
+@pytest.fixture
+def fixtures_dir() -> Path:
+    """Fixture that provides the path to the test fixtures directory."""
+    return Path(__file__).parent / 'fixtures'
+
+
+@pytest.fixture
+def images_dir(fixtures_dir: Path) -> Path:
+    """Fixture that provides the path to the test images directory."""
+    return fixtures_dir / 'images'
+
+
+@pytest.fixture
+def sample_image_path(images_dir: Path) -> Path:
+    """Fixture that provides a sample image path."""
+    return images_dir / 'page-000.jpg'
+
+
+@pytest.fixture
+def sample_cbz_file(tmp_path: Path, images_dir: Path) -> Path:
+    """Fixture that creates a sample CBZ file for testing."""
+    # Load sample pages
+    image_paths = sorted(list(images_dir.iterdir()))[:3]  # Use first 3 images
+    pages = []
+
+    for i, path in enumerate(image_paths):
+        page_type = PageType.FRONT_COVER if i == 0 else PageType.STORY
+        page = PageInfo.load(path=path, type=page_type)
+        pages.append(page)
+
+    # Create comic from pages
+    comic = ComicInfo.from_pages(
+        pages=pages,
+        title='Test Comic',
+        series='Test Series',
+        number=1,
+        volume=1,
+        year=2024
+    )
+
+    # Save to temporary file
+    cbz_path = tmp_path / 'test_comic.cbz'
+    cbz_content = comic.pack()
+    cbz_path.write_bytes(cbz_content)
+
+    return cbz_path

tests/example.py

@@ -7,7 +7,7 @@ from cbz.page import PageInfo
 PARENT = Path(__file__).parent
 
 if __name__ == '__main__':
-    paths = list((PARENT / 'images').iterdir())
+    paths = list((PARENT / 'fixtures' / 'images').iterdir())
 
     # Load each page from the 'images' folder into a list of PageInfo objects
     pages = [

tests/test_comic.py

@@ -0,0 +1,179 @@
+import tempfile
+from pathlib import Path
+from typing import List
+
+from cbz.comic import ComicInfo
+from cbz.page import PageInfo
+from cbz.constants import PageType, YesNo, Manga, AgeRating, Format
+
+
+class TestComicInfo:
+    """Test cases for ComicInfo class."""
+
+    def test_from_pages_creation(self, images_dir: Path) -> None:
+        """Test creating ComicInfo from pages."""
+        # Load sample pages
+        image_paths = sorted(list(images_dir.iterdir()))[:3]  # Use first 3 images
+        pages: List[PageInfo] = []
+
+        for i, path in enumerate(image_paths):
+            page_type = PageType.FRONT_COVER if i == 0 else PageType.STORY
+            page = PageInfo.load(path=path, type=page_type)
+            pages.append(page)
+
+        # Create comic from pages
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title='Test Comic',
+            series='Test Series',
+            number=1,
+            volume=1,
+            year=2024
+        )
+
+        assert comic.title == 'Test Comic'
+        assert comic.series == 'Test Series'
+        assert comic.number == 1
+        assert comic.volume == 1
+        assert comic.year == 2024
+        assert len(comic.pages) == 3
+        assert comic.pages[0].type == PageType.FRONT_COVER
+        assert comic.pages[1].type == PageType.STORY
+
+    def test_from_cbz_file(self, sample_cbz_file: Path) -> None:
+        """Test loading ComicInfo from CBZ file."""
+        comic = ComicInfo.from_cbz(sample_cbz_file)
+
+        assert comic is not None
+        assert hasattr(comic, 'pages')
+        assert len(comic.pages) > 0
+        assert all(isinstance(page, PageInfo) for page in comic.pages)
+
+    def test_pack_cbz(self, images_dir: Path) -> None:
+        """Test packing comic into CBZ format."""
+        # Create a simple comic
+        image_paths = sorted(list(images_dir.iterdir()))[:2]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title='Pack Test',
+            series='Test Series'
+        )
+
+        # Pack to CBZ
+        cbz_content = comic.pack()
+
+        assert isinstance(cbz_content, bytes)
+        assert len(cbz_content) > 0
+
+    def test_pack_with_rename(self, images_dir: Path) -> None:
+        """Test packing comic with page renaming."""
+        image_paths = sorted(list(images_dir.iterdir()))[:2]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title='Rename Test'
+        )
+
+        # Pack with rename option
+        cbz_content = comic.pack(rename=True)
+
+        assert isinstance(cbz_content, bytes)
+        assert len(cbz_content) > 0
+
+    def test_comic_metadata_properties(self, images_dir: Path) -> None:
+        """Test comic metadata properties."""
+        image_paths = sorted(list(images_dir.iterdir()))[:1]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title='Metadata Test',
+            series='Test Series',
+            number=5,
+            count=10,
+            volume=2,
+            summary='Test summary',
+            year=2023,
+            month=6,
+            day=15,
+            writer='Test Writer',
+            penciller='Test Penciller',
+            inker='Test Inker',
+            colorist='Test Colorist',
+            letterer='Test Letterer',
+            cover_artist='Test Cover Artist',
+            editor='Test Editor',
+            publisher='Test Publisher',
+            imprint='Test Imprint',
+            genre='Test Genre',
+            language_iso='en',
+            format=Format.SERIES,
+            black_white=YesNo.NO,
+            manga=Manga.RIGHT_LEFT,
+            age_rating=AgeRating.TEEN,
+            community_rating=4
+        )
+
+        assert comic.title == 'Metadata Test'
+        assert comic.series == 'Test Series'
+        assert comic.number == 5
+        assert comic.count == 10
+        assert comic.volume == 2
+        assert comic.summary == 'Test summary'
+        assert comic.year == 2023
+        assert comic.month == 6
+        assert comic.day == 15
+        assert comic.writer == 'Test Writer'
+        assert comic.penciller == 'Test Penciller'
+        assert comic.inker == 'Test Inker'
+        assert comic.colorist == 'Test Colorist'
+        assert comic.letterer == 'Test Letterer'
+        assert comic.cover_artist == 'Test Cover Artist'
+        assert comic.editor == 'Test Editor'
+        assert comic.publisher == 'Test Publisher'
+        assert comic.imprint == 'Test Imprint'
+        assert comic.genre == 'Test Genre'
+        assert comic.language_iso == 'en'
+        assert comic.format == Format.SERIES
+        assert comic.black_white == YesNo.NO
+        assert comic.manga == Manga.RIGHT_LEFT
+        assert comic.age_rating == AgeRating.TEEN
+        assert comic.community_rating == 4
+
+    def test_page_count_property(self, images_dir: Path) -> None:
+        """Test that page count returns correct count."""
+        image_paths = sorted(list(images_dir.iterdir()))[:4]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+
+        comic = ComicInfo.from_pages(pages=pages, title='Count Test')
+
+        assert len(comic.pages) == 4
+
+    def test_empty_pages_list(self) -> None:
+        """Test creating comic with empty pages list."""
+        comic = ComicInfo.from_pages(pages=[], title='Empty Test')
+
+        assert comic.title == 'Empty Test'
+        assert len(comic.pages) == 0
+
+    def test_single_page_comic_load(self, images_dir):
+        """Test loading comic with a single page."""
+        image_paths = sorted(list(images_dir.iterdir()))[:1]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+
+        comic = ComicInfo.from_pages(pages=pages, title="Single Page Test")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir) / "single_page.cbz"
+            data = comic.pack()
+            with open(temp_path, "wb") as f:
+                f.write(data)
+
+            assert temp_path.exists()
+
+            comic_loaded = ComicInfo.from_cbz(temp_path)
+            assert comic_loaded.title == "Single Page Test"
+            assert len(comic_loaded.pages) == 1

tests/test_models.py

@@ -0,0 +1,265 @@
+from cbz.models import BaseModel, ComicModel, PageModel
+from cbz.constants import Format, YesNo, Manga, AgeRating, PageType
+
+
+class TestBaseModel:
+    """Test cases for BaseModel class."""
+
+    def test_base_model_creation(self) -> None:
+        """Test creating BaseModel with fields."""
+        test_fields = {
+            'test_str': ('Test String', str),
+            'test_int': ('Test Integer', int),
+            'test_bool': ('Test Boolean', bool)
+        }
+
+        model = BaseModel(fields=test_fields)
+
+        # Check default values are set
+        assert hasattr(model, 'test_str')
+        assert hasattr(model, 'test_int')
+        assert hasattr(model, 'test_bool')
+
+    def test_base_model_with_kwargs(self) -> None:
+        """Test creating BaseModel with keyword arguments."""
+        test_fields = {
+            'title': ('Title', str),
+            'number': ('Number', int),
+            'published': ('Published', bool)
+        }
+
+        model = BaseModel(
+            fields=test_fields,
+            title='Test Title',
+            number=42,
+            published=True
+        )
+
+        assert model.title == 'Test Title'
+        assert model.number == 42
+        assert model.published
+
+    def test_attribute_type_verification(self) -> None:
+        """Test that attribute types are verified on assignment."""
+        test_fields = {
+            'count': ('Count', int),
+            'name': ('Name', str)
+        }
+
+        model = BaseModel(fields=test_fields)
+
+        # Valid assignments
+        model.count = 10
+        model.name = 'Test'
+
+        assert model.count == 10
+        assert model.name == 'Test'
+
+    def test_repr_method(self) -> None:
+        """Test string representation of BaseModel."""
+        test_fields = {
+            'title': ('Title', str)
+        }
+
+        model = BaseModel(fields=test_fields, title='Test')
+        repr_str = repr(model)
+
+        assert isinstance(repr_str, str)
+        assert 'BaseModel' in repr_str
+
+
+class TestComicModel:
+    """Test cases for ComicModel class."""
+
+    def test_comic_model_creation(self) -> None:
+        """Test creating ComicModel with default values."""
+        model = ComicModel()
+
+        # Check that comic-specific attributes exist
+        assert hasattr(model, 'title')
+        assert hasattr(model, 'series')
+        assert hasattr(model, 'number')
+        assert hasattr(model, 'volume')
+        assert hasattr(model, 'year')
+        assert hasattr(model, 'month')
+        assert hasattr(model, 'day')
+
+    def test_comic_model_with_values(self) -> None:
+        """Test creating ComicModel with specific values."""
+        model = ComicModel(
+            title='Test Comic',
+            series='Test Series',
+            number=1,
+            volume=1,
+            year=2024,
+            month=6,
+            day=15,
+            writer='Test Writer',
+            publisher='Test Publisher',
+            language_iso='en',
+            format=Format.SERIES,
+            black_white=YesNo.NO,
+            manga=Manga.RIGHT_LEFT,
+            age_rating=AgeRating.EVERYONE
+        )
+
+        assert model.title == 'Test Comic'
+        assert model.series == 'Test Series'
+        assert model.number == 1
+        assert model.volume == 1
+        assert model.year == 2024
+        assert model.month == 6
+        assert model.day == 15
+        assert model.writer == 'Test Writer'
+        assert model.publisher == 'Test Publisher'
+        assert model.language_iso == 'en'
+        assert model.format == Format.SERIES
+        assert model.black_white == YesNo.NO
+        assert model.manga == Manga.RIGHT_LEFT
+        assert model.age_rating == AgeRating.EVERYONE
+
+    def test_comic_model_enum_properties(self) -> None:
+        """Test that enum properties work correctly."""
+        model = ComicModel()
+
+        # Test format enum
+        model.format = Format.PREVIEW
+        assert model.format == Format.PREVIEW
+
+        # Test yes/no enum
+        model.black_white = YesNo.YES
+        assert model.black_white == YesNo.YES
+
+        # Test manga enum
+        model.manga = Manga.RIGHT_LEFT
+        assert model.manga == Manga.RIGHT_LEFT
+
+        # Test age rating enum
+        model.age_rating = AgeRating.TEEN
+        assert model.age_rating == AgeRating.TEEN
+
+    def test_comic_model_metadata_fields(self) -> None:
+        """Test comic metadata fields."""
+        model = ComicModel(
+            summary='Test summary',
+            notes='Test notes',
+            genre='Adventure',
+            web='http://example.com',
+            ean='1234567890123',
+            community_rating=5,
+            main_character_or_team='Hero',
+            characters='Hero, Villain',
+            teams='Justice League',
+            locations='Metropolis',
+            scan_information='Scanned by Test',
+            story_arc='Origin Story',
+            series_group='DC Comics',
+            alternate_series='Alternate Universe',
+            alternate_number=2,
+            alternate_count=10
+        )
+
+        assert model.summary == 'Test summary'
+        assert model.notes == 'Test notes'
+        assert model.genre == 'Adventure'
+        assert model.web == 'http://example.com'
+        assert model.ean == '1234567890123'
+        assert model.community_rating == 5
+        assert model.main_character_or_team == 'Hero'
+        assert model.characters == 'Hero, Villain'
+        assert model.teams == 'Justice League'
+        assert model.locations == 'Metropolis'
+        assert model.scan_information == 'Scanned by Test'
+        assert model.story_arc == 'Origin Story'
+        assert model.series_group == 'DC Comics'
+        assert model.alternate_series == 'Alternate Universe'
+        assert model.alternate_number == 2
+        assert model.alternate_count == 10
+
+
+class TestPageModel:
+    """Test cases for PageModel class."""
+
+    def test_page_model_creation(self) -> None:
+        """Test creating PageModel with default values."""
+        model = PageModel()
+
+        # Check that page-specific attributes exist
+        assert hasattr(model, 'image')
+        assert hasattr(model, 'type')
+        assert hasattr(model, 'double')
+        assert hasattr(model, 'image_size')
+        assert hasattr(model, 'key')
+        assert hasattr(model, 'bookmark')
+        assert hasattr(model, 'image_width')
+        assert hasattr(model, 'image_height')
+        assert hasattr(model, 'image_size')
+        # Note: format is not a base field in PageModel
+
+    def test_page_model_with_values(self) -> None:
+        """Test creating PageModel with specific values."""
+        model = PageModel(
+            type=PageType.FRONT_COVER,
+            double=True,
+            image_size=1024000,
+            key='cover',
+            bookmark='Chapter 1',
+            image_width=800,
+            image_height=1200,
+        )
+
+        assert model.type == PageType.FRONT_COVER
+        assert model.double
+        assert model.image_size == 1024000
+        assert model.key == 'cover'
+        assert model.bookmark == 'Chapter 1'
+        assert model.image_width == 800
+        assert model.image_height == 1200
+
+    def test_page_model_page_types(self) -> None:
+        """Test different page types."""
+        page_types = [
+            PageType.FRONT_COVER,
+            PageType.INNER_COVER,
+            PageType.ROUNDUP,
+            PageType.STORY,
+            PageType.ADVERTISEMENT,
+            PageType.EDITORIAL,
+            PageType.LETTERS,
+            PageType.PREVIEW,
+            PageType.BACK_COVER,
+            PageType.OTHER,
+            PageType.DELETED
+        ]
+
+        for page_type in page_types:
+            model = PageModel(type=page_type)
+            assert model.type == page_type
+
+    def test_page_model_boolean_properties(self) -> None:
+        """Test boolean properties in PageModel."""
+        model = PageModel()
+
+        # Test double property
+        model.double = True
+        assert model.double
+
+        model.double = False
+        assert not model.double
+
+    def test_page_model_numeric_properties(self) -> None:
+        """Test numeric properties in PageModel."""
+        model = PageModel(
+            image_size=2048000,
+            image_width=1920,
+            image_height=1080
+        )
+
+        assert model.image_size == 2048000
+        assert model.image_width == 1920
+        assert model.image_height == 1080
+
+        # Test that they're integers
+        assert isinstance(model.image_size, int)
+        assert isinstance(model.image_width, int)
+        assert isinstance(model.image_height, int)

tests/test_page.py

@@ -0,0 +1,143 @@
+from pathlib import Path
+
+import pytest
+
+from cbz.page import PageInfo
+from cbz.constants import PageType
+
+
+class TestPageInfo:
+    """Test cases for PageInfo class."""
+
+    def test_load_from_file(self, sample_image_path: Path) -> None:
+        """Test loading PageInfo from image file."""
+        page = PageInfo.load(path=sample_image_path)
+
+        assert page is not None
+        assert isinstance(page.content, bytes)
+        assert len(page.content) > 0
+        assert page.name == sample_image_path.name
+        assert page.image_width > 0
+        assert page.image_height > 0
+        assert page.image_size > 0
+        assert page.suffix is not None
+
+    def test_load_with_page_type(self, sample_image_path: Path) -> None:
+        """Test loading PageInfo with specific page type."""
+        page = PageInfo.load(path=sample_image_path, type=PageType.FRONT_COVER)
+
+        assert page.type == PageType.FRONT_COVER
+
+    def test_load_with_custom_name(self, sample_image_path: Path) -> None:
+        """Test loading PageInfo with custom name."""
+        custom_name = 'custom_page.jpg'
+        page = PageInfo.load(path=sample_image_path, name=custom_name)
+
+        assert page.name == custom_name
+
+    def test_page_content_property(self, sample_image_path: Path) -> None:
+        """Test page content property getter and setter."""
+        page = PageInfo.load(path=sample_image_path)
+        original_content = page.content
+
+        # Test getter
+        assert page.content == original_content
+        assert isinstance(page.content, bytes)
+
+        # Test that content is properly set and metadata extracted
+        assert page.image_width > 0
+        assert page.image_height > 0
+        assert page.image_size > 0
+
+    def test_image_metadata_extraction(self, sample_image_path: Path) -> None:
+        """Test that image metadata is correctly extracted."""
+        page = PageInfo.load(path=sample_image_path)
+
+        # Check that all image metadata properties are set
+        assert hasattr(page, 'image_width') and page.image_width > 0
+        assert hasattr(page, 'image_height') and page.image_height > 0
+        assert hasattr(page, 'image_size') and page.image_size > 0
+        assert hasattr(page, 'suffix') and page.suffix is not None
+
+        # Verify dimensions make sense for an image
+        assert isinstance(page.image_width, int)
+        assert isinstance(page.image_height, int)
+        assert isinstance(page.image_size, int)
+
+    def test_multiple_image_formats(self, images_dir: Path) -> None:
+        """Test loading different image formats."""
+        image_files = list(images_dir.glob('*.jpg'))
+
+        if not image_files:
+            pytest.skip('No image files found in example directory')
+
+        for image_path in image_files[:3]:  # Test first 3 images
+            page = PageInfo.load(path=image_path)
+
+            assert page is not None
+            assert isinstance(page.content, bytes)
+            assert len(page.content) > 0
+            assert page.image_width > 0
+            assert page.image_height > 0
+            assert page.image_size > 0
+
+    def test_page_type_assignment(self, sample_image_path: Path) -> None:
+        """Test different page type assignments."""
+        page_types = [
+            PageType.FRONT_COVER,
+            PageType.INNER_COVER,
+            PageType.ROUNDUP,
+            PageType.STORY,
+            PageType.ADVERTISEMENT,
+            PageType.EDITORIAL,
+            PageType.LETTERS,
+            PageType.PREVIEW,
+            PageType.BACK_COVER,
+            PageType.OTHER,
+            PageType.DELETED
+        ]
+
+        for page_type in page_types:
+            page = PageInfo.load(path=sample_image_path, type=page_type)
+            assert page.type == page_type
+
+    def test_page_creation_from_bytes(self, sample_image_path: Path) -> None:
+        """Test creating PageInfo directly from bytes."""
+        # Read image file as bytes
+        with open(sample_image_path, 'rb') as f:
+            image_bytes = f.read()
+
+        # Create page from bytes
+        page = PageInfo(content=image_bytes, name='test_page.jpg')
+
+        assert page.content == image_bytes
+        assert page.name == 'test_page.jpg'
+        assert page.image_width > 0
+        assert page.image_height > 0
+        assert page.image_size > 0
+
+    def test_repr_string(self, sample_image_path: Path) -> None:
+        """Test string representation of PageInfo."""
+        page = PageInfo.load(path=sample_image_path, type=PageType.STORY)
+
+        repr_str = repr(page)
+        assert 'PageInfo' in repr_str
+        assert isinstance(repr_str, str)
+
+    def test_page_bookmark_property(self, sample_image_path: Path) -> None:
+        """Test page bookmark property."""
+        # Test with bookmark
+        page = PageInfo.load(path=sample_image_path, bookmark='Chapter 1')
+        assert page.bookmark == 'Chapter 1'
+
+        # Test without bookmark
+        page_no_bookmark = PageInfo.load(path=sample_image_path)
+        assert hasattr(page_no_bookmark, 'bookmark')
+
+    def test_page_double_page_property(self, sample_image_path: Path) -> None:
+        """Test page double_page property."""
+        page = PageInfo.load(path=sample_image_path, double=True)
+        assert page.double
+
+        page_no_double = PageInfo.load(path=sample_image_path)
+        assert hasattr(page_no_double, 'double')