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

@@ -0,0 +1,177 @@
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### CBZ ###
+*.cbz
+*.pdf
+*.zip
+*cbr

CHANGELOG.md

@@ -2,8 +2,204 @@
 
 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
+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).
-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
+
+- Option to not rename the name of image files loaded into pages.
+
+### Fixed
+
+- Removing deprecated datetime api for utcnow.
+
+## [3.3.5] - 2024-07-22
+
+### Fixed
+
+- Fix `Path` import using `pathlib`.
+
+## [3.3.4] - 2024-07-18
+
+### Fixed
+
+- Remove invalid dict key.
+- Fix invalid utc format.
+
+## [3.3.3] - 2024-07-18
+
+### Added
+
+- Reference links for XML schema.
+- New information fields in the XML.
+- Support PDF files via `cbzplayer` command.
+
+### Changed
+
+- Removed MD5 display in the player (irrelevant).
+- The displayed size in the player now reflects the total size of all images.
+- Simplified the closing XML `Page` tag.
+- Sorted `Page` keys in order.
+- Updated `ComicInfo.xsd` defining the CBZ standard.
+
+### Fixed
+
+- Fixed the `.jpg` constant preventing the use of certain images.
+- Fixed memory error related to the `pack()` method cache.
+- Fixed saving pages in XML to comply with the standard.
+- Added missing mandatory keys in the XML.
+
+## [3.3.2] - 2024-07-18
+
+### Added
+
+- Added zoom options for displaying images in the player.
+- Added scroll functionality for image display in the player, especially useful when images are zoomed.
+
+### Changed
+
+- Set a default standard size.
+
+### Fixed
+
+- Fix lag when stretching player.
+- Fix XML parsing for CBZ files with a single page.
+- Fix image positioning within the player.
+
+### New Contributors
+
+- [gokender](https://github.com/gokender)
+
+## [3.3.1] - 2024-07-15
+
+### Added
+
+- Added `from_pdf` method to convert `.pdf` files to `.cbz`.
+
+### Changed
+
+- Set a default standard size.
+- Changed a keyboard shortcut that prevented copying information.
+
+### Fixed
+
+- Fixed the icon display for Linux in the player.
+- Fixed the taskbar icon for Windows in the player.
+- Fixed the player margins.
+- Automatically detect the player size based on the smallest image.
+
+### New Contributors
+
+- [flolep2607](https://github.com/flolep2607)
+
+## [3.3.0] - 2024-07-14
+
+### Added
+
+- Type value verification.
+- Load ComicInfo from a `cbz` file.
+- Built-in reader for dynamic viewing.
+- Image compatibility checking.
+- Added `save` method to directly save a page or comic.
+- Display additional file information via the player.
+
+### Changed
+
+- Complete code refactoring.
+- `pages` variable now public for native page manipulation in Python.
+- Optimized `pack` function with caching.
+- Library now supports loading `zip` files containing only images.
+
+### Fixed
+
+- Default value definitions.
+- Corrected values written to XML.
+
+### New Contributors
+
+- [piskunqa](https://github.com/piskunqa)
+- [OleskiiPyskun](https://github.com/OleskiiPyskun)
+- [domenicoblanco](https://github.com/domenicoblanco)
+- [RivMt](https://github.com/RivMt)
+
+## [3.2.0] - 2024-03-17
+
+### Changed
+
+- New code structure.
+- Deleting temporary files usage.
+- Automatic correction of variable types.
+- Simplifying constants.
+- Binary input support for pages.
+- Project `pycbzhelper` renamed to `cbz`.
+
+## [3.1.2] - 2023-08-13
+
+### Fixed
+
+- Fixed missing `Tags` key, thanks to @RivMt
 
 ## [3.1.1] - 2023-06-04
 
@@ -36,6 +232,22 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - Initial release.
 
-[3.1.1]: https://github.com/hyugogirubato/pycbzhelper/releases/tag/v3.1.1
+[3.4.5]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.5
-[3.1.0]: https://github.com/hyugogirubato/pycbzhelper/releases/tag/v3.1.0
+[3.4.4]: https://github.com/hyugogirubato/cbz/releases/tag/v3.4.4
-[3.0.1]: https://github.com/hyugogirubato/pycbzhelper/releases/tag/v3.0.1
+[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
+[3.3.3]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.3
+[3.3.2]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.2
+[3.3.1]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.1
+[3.3.0]: https://github.com/hyugogirubato/cbz/releases/tag/v3.3.0
+[3.2.0]: https://github.com/hyugogirubato/cbz/releases/tag/v3.2.0
+[3.1.2]: https://github.com/hyugogirubato/cbz/releases/tag/v3.1.2
+[3.1.1]: https://github.com/hyugogirubato/cbz/releases/tag/v3.1.1
+[3.1.0]: https://github.com/hyugogirubato/cbz/releases/tag/v3.1.0
+[3.0.1]: https://github.com/hyugogirubato/cbz/releases/tag/v3.0.1

LICENSE

@@ -1,674 +1,21 @@
-                    GNU GENERAL PUBLIC LICENSE
+MIT License
-                       Version 3, 29 June 2007
+
-
+Copyright (c) 2025 hyugogirubato
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+
- Everyone is permitted to copy and distribute verbatim copies
+Permission is hereby granted, free of charge, to any person obtaining a copy
- of this license document, but changing it is not allowed.
+of this software and associated documentation files (the "Software"), to deal
-
+in the Software without restriction, including without limitation the rights
-                            Preamble
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-
+copies of the Software, and to permit persons to whom the Software is
-  The GNU General Public License is a free, copyleft license for
+furnished to do so, subject to the following conditions:
-software and other kinds of works.
+
-
+The above copyright notice and this permission notice shall be included in all
-  The licenses for most software and other practical works are designed
+copies or substantial portions of the Software.
-to take away your freedom to share and change the works.  By contrast,
+
-the GNU General Public License is intended to guarantee your freedom to
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-share and change all versions of a program--to make sure it remains free
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-software for all its users.  We, the Free Software Foundation, use the
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-GNU General Public License for most of our software; it applies also to
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-any other work released this way by its authors.  You can apply it to
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-your programs, too.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-
+SOFTWARE.
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,73 +1,227 @@
-# PyCBZHelper
+# CBZ
 
-[![License](https://img.shields.io/github/license/hyugogirubato/pycbzhelper)](https://github.com/hyugogirubato/pycbzhelper/blob/main/LICENSE)
+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.
-[![Release](https://img.shields.io/github/release-date/hyugogirubato/pycbzhelper)](https://github.com/hyugogirubato/pycbzhelper/releases)
-[![Latest Version](https://img.shields.io/pypi/v/pycbzhelper)](https://pypi.org/project/pycbzhelper/)
-
-PyCBZHelper is a Python library for creating CBZ (Comic Book Zip) files with metadata. It provides functionality to
-generate a CBZ file from a list of image pages and associated comic book metadata.
 
 ## Features
 
-- Create CBZ files from images.
+- 🚀 Seamless Installation via [pip](#installation)
-- Generate ComicInfo.xml metadata.
+- 📚 Pack images into CBZ format for comics and manga
-- Support for various metadata fields.
+- 📝 Extract and manage title, series, format, and more
-- Handle page files from local disk or web URLs.
+- 🖼️ Handle comic pages with attributes like type and format
-- Automatic cleanup of temporary files.
+- 📦 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
 
-You can install PyCBZHelper using pip:
+Install CBZ from PyPI using pip:
 
-````shell
+```shell
-pip install pycbzhelper
+pip install cbz
-````
+```
 
-## Usage
+## Quick Start
 
-Here's a basic example of how to use PyCBZHelper:
+Here's a quick example of how to create a CBZ file from a series of images:
 
 ````python
-from pycbzhelper import Helper
 from pathlib import Path
 
-PARENT = Path(__name__).resolve().parent
+from cbz.comic import ComicInfo
+from cbz.constants import PageType, YesNo, Manga, AgeRating, Format
+from cbz.page import PageInfo
 
-if __name__ == "__main__":
+PARENT = Path(__file__).parent
-    # Define metadata for the comic
-    metadata = {
-        "Title": "My Comic",
-        "Series": "Comic Series",
-        "Number": "1",
-        "Pages": [
-            {"File": PARENT / "image1.jpg"},
-            {"File": PARENT / "image2.jpg"},
-        ]
-        # Add more metadata fields here
-    }
 
-    # Define the path to the output CBZ file
+if __name__ == '__main__':
-    output_path = PARENT / "output.cbz"
+    paths = list(Path('path/to/your/images').iterdir())
 
-    # Create an instance of the Helper class
+    # Load each page from the 'images' folder into a list of PageInfo objects
-    helper = Helper(metadata)
+    pages = [
+        PageInfo.load(
+            path=path,
+            type=PageType.FRONT_COVER if i == 0 else PageType.BACK_COVER if i == len(paths) - 1 else PageType.STORY
+        )
+        for i, path in enumerate(paths)
+    ]
 
-    # Create the CBZ file
+    # Create a ComicInfo object using ComicInfo.from_pages() method
-    helper.create_cbz(output_path)
+    comic = ComicInfo.from_pages(
+        pages=pages,
+        title='Your Comic Title',
+        series='Your Comic Series',
+        number=1,
+        language_iso='en',
+        format=Format.WEB_COMIC,
+        black_white=YesNo.NO,
+        manga=Manga.NO,
+        age_rating=AgeRating.PENDING
+    )
+
+    # Show the comic using the show()
+    comic.show()
+
+    # Pack the comic book content into a CBZ file format
+    cbz_content = comic.pack()
+
+    # Define the path where the CBZ file will be saved
+    cbz_path = PARENT / 'your_comic.cbz'
+
+    # Write the CBZ content to the specified path
+    cbz_path.write_bytes(cbz_content)
 ````
 
-For more information on how to use PyCBZHelper, please refer to
+## Player
-the [documentation](https://github.com/hyugogirubato/pycbzhelper/blob/main/docs/schema).
 
-### Exceptions
+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.
 
-The following exceptions can be raised by PyCBZHelper:
+### Supported Formats
 
-- `InvalidKeyValue`: Raised when a key value is invalid.
+- **CBZ** (Comic Book ZIP) - Standard ZIP archives containing images and metadata
-- `MissingPageFile`: Raised when no page files are available.
+- **CBR** (Comic Book RAR) - RAR archives containing images and metadata
-- `InvalidFileExtension`: Raised when an invalid file extension is used.
+- **PDF** - Portable Document Format files with embedded images (images only, no metadata)
-- `FileNotFound`: Raised when the specified source file is not found.
 
-### License
+### Usage
 
-This project is licensed under the [GPL v3 License](https://github.com/hyugogirubato/pycbzhelper/blob/main/LICENSE).
+````shell
+usage: cbzplayer [-h] <file>
+
+Launch CBZ player with a comic book file
+
+positional arguments:
+  <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
+
+The `ComicInfo` class represents a comic book with metadata and pages. It supports initialization from a list of `PageInfo` objects:
+
+```python
+from cbz.comic import ComicInfo
+from cbz.constants import PageType, YesNo, Manga, AgeRating, Format
+from cbz.page import PageInfo
+
+# Example usage:
+pages = [
+    PageInfo.load(path='/path/to/page1.jpg', type=PageType.FRONT_COVER),
+    PageInfo.load(path='/path/to/page2.jpg', type=PageType.STORY),
+    PageInfo.load(path='/path/to/page3.jpg', type=PageType.BACK_COVER),
+]
+
+comic = ComicInfo.from_pages(
+    pages=pages,
+    title='My Comic',
+    series='Comic Series',
+    number=1,
+    language_iso='en',
+    format=Format.WEB_COMIC,
+    black_white=YesNo.NO,
+    manga=Manga.NO,
+    age_rating=AgeRating.PENDING
+)
+```
+
+### Extracting Metadata
+
+Retrieve comic information as a dictionary using `get_info()`:
+
+```python
+info = comic.get_info()
+print(info)
+```
+
+### Packing into CBZ Format
+
+Pack the comic into a CBZ file format:
+
+```python
+cbz_content = comic.pack()
+```
+
+### Loading from Different Formats
+
+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>
+
+## Licensing
+
+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
+
+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

@@ -0,0 +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

@@ -0,0 +1,37 @@
+import argparse
+
+from pathlib import Path
+
+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, CBR, or PDF comic book file.')
+    args = parser.parse_args()
+
+    # Validate the provided path
+    comic_path = args.comic_path
+    if not comic_path.is_file():
+        print(f'Error: The file "{comic_path}" does not exist or is not a valid file.')
+        exit(1)
+
+    # Create ComicInfo object from comic file
+    try:
+        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:
+        print(f'Error: {e}')
+        exit(1)
+
+
+if __name__ == '__main__':
+    main()

cbz/comic.py

@@ -0,0 +1,322 @@
+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, List
+from pathlib import Path
+
+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
+from cbz.utils import repr_attr
+
+
+class ComicInfo(ComicModel):
+    """
+    ComicInfo class that represents the comic book information and pages.
+    """
+
+    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.
+            **kwargs: Additional attributes for the comic.
+
+        Attributes:
+            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:
+        """
+        Create a ComicInfo instance from pages and additional attributes.
+
+        Args:
+            pages (List[PageInfo]): List of PageInfo objects representing the comic pages.
+            **kwargs: Additional attributes for the comic.
+
+        Returns:
+            ComicInfo: An instance of ComicInfo.
+        """
+        return cls(pages, **kwargs)
+
+    @classmethod
+    def from_cbz(cls, path: Union[Path, str]) -> ComicInfo:
+        """
+        Create a ComicInfo instance from a CBZ file.
+
+        Args:
+            path (Union[Path, str]): Path to the CBZ 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_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:
+        """
+        Create a ComicInfo instance from a PDF file.
+
+        Args:
+            path (Union[Path, str]): Path to the PDF 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_pdf(Path(path))
+
+    @staticmethod
+    def __unpack_pdf(path: Path) -> ComicInfo:
+        """
+        Unpack a PDF file and create a ComicInfo instance.
+
+        Args:
+            path (Path): Path to the PDF file.
+
+        Returns:
+            ComicInfo: An instance of ComicInfo.
+        """
+        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:
+        """
+        Unpack a CBZ file and create a ComicInfo instance.
+
+        Args:
+            path (Path): Path to the CBZ file.
+
+        Returns:
+            ComicInfo: An instance of ComicInfo.
+        """
+        with zipfile.ZipFile(path, 'r', zipfile.ZIP_STORED) as zf:
+            return ComicInfo.__process_archive(zf)
+
+    def get_info(self) -> dict:
+        """
+        Get the comic information as a dictionary.
+
+        Returns:
+            dict: Dictionary containing comic information.
+        """
+
+        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, _) in fields.items():
+                item = items.get(key)
+                if item and not (isinstance(item, Enum) and item.name == 'UNKNOWN' or item == -1):
+                    content[field_key] = repr_attr(item)
+            return content
+
+        comic_info = __info(
+            items={k: v for k, v in self.__dict__.items() if not k.startswith('_')},
+            fields=COMIC_FIELDS)
+
+        comic_pages = []
+        for i, page in enumerate(self.pages):
+            page_info = __info(
+                items={k: v for k, v in page.__dict__.items() if not k.startswith('_')},
+                fields=PAGE_FIELDS)
+            page_info['@Image'] = i
+            comic_pages.append(dict(sorted(page_info.items())))
+
+        # https://github.com/anansi-project/rfcs/issues/3#issuecomment-671631676
+        utcnow = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
+        comic_info.update({
+            '@xmlns:xsd': 'http://www.w3.org/2001/XMLSchema',
+            '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+            'FileSize': comic_info.get('FileSize', sum(p.image_size for p in self.pages)),
+            'FileCreationTime': comic_info.get('FileCreationTime', utcnow),
+            'FileModifiedTime': comic_info.get('FileModifiedTime', utcnow),
+            'PageCount': len(self.pages),
+            'Pages': {'Page': comic_pages}
+        })
+        return comic_info
+
+    def pack(self, rename: bool = True) -> bytes:
+        """
+        Pack the comic information and pages into a CBZ file format.
+
+        Args:
+            rename (bool): Whether to rename pages to a sequential format (e.g., 'page-001.jpg').
+
+        Returns:
+            bytes: Bytes representing the packed CBZ file.
+        """
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_STORED) as zf:
+            content = xmltodict.unparse({'ComicInfo': self.get_info()}, pretty=True)
+            zf.writestr(
+                XML_NAME,
+                content.replace('></Page>', ' />').encode('utf-8')
+            )
+            for i, page in enumerate(self.pages):
+                name = page.name
+                # If the page does not have a name or renaming is enabled, generate a sequential name for the page.
+                if not name or rename:
+                    name = f'page-{i + 1:03d}{page.suffix}'
+                zf.writestr(name, page.content)
+
+        packed = zip_buffer.getvalue()
+        zip_buffer.close()
+        return packed
+
+    def show(self) -> None:
+        """
+        Display the comic using the Player class.
+
+        This method initializes a Player instance with the comic information
+        and starts the player to show the comic.
+        """
+        # Avoid circular import
+        from cbz.player import Player
+        player = Player(self)
+        player.run()
+
+    def save(self, path: Union[Path, str]) -> None:
+        """
+        Save the comic book as a CBZ file to the specified path.
+
+        Args:
+            path (Union[Path, str]): Path where the CBZ file will be saved.
+        """
+        with Path(path).open(mode='wb') as f:
+            f.write(self.pack())

cbz/constants.py

@@ -0,0 +1,197 @@
+from enum import Enum
+from typing import Union
+
+from langcodes import Language
+
+XML_NAME = "ComicInfo.xml"
+IMAGE_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"
+
+
+class Manga(Enum):
+    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"
+
+
+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+"
+
+
+class Format(Enum):
+    UNKNOWN = "Unknown"
+    # ONE_SHOT = '1 Shot'
+    # ONE_SHOT = '1/2',
+    # ONE_SHOT = '1-Shot'
+    ANNOTATION = "Annotation"
+    # ANNOTATIONS = 'Annotations'
+    ANNUAL = "Annual"
+    ANTHOLOGY = "Anthology"
+    # BLACK_WHITE = 'B&W'
+    # BLACK_WHITE = 'B/W'
+    # BLACK_WHITE = 'B&&W'
+    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"
+    # GIANT_SIZE = 'Giant'
+    # GIANT_SIZE = 'Giant Size'
+    GIANT_SIZE = "Giant-Size"
+    GRAPHIC_NOVEL = "Graphic Novel"
+    # HARDCOVER = 'Hardcover'
+    HARDCOVER = "Hard-Cover"
+    # KING_SIZE = 'King'
+    # KING_SIZE = 'King Size'
+    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"
+    # TRADE_PAPER_BACK = 'TPB'
+    TRADE_PAPER_BACK = "Trade Paper Back"
+    # WEB_COMIC = 'WebComic'
+    WEB_COMIC = "Web Comic"
+    # YEAR_ONE = 'Year 1'
+    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}"
+        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"
+        return super().__new__(cls, value)
+
+
+COMIC_FIELDS = {
+    "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),
+}

cbz/models.py

@@ -0,0 +1,170 @@
+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:
+
+    def __init__(self, fields: dict, **kwargs):
+        """
+        Initializes the BaseModel instance.
+
+        Args:
+            fields (dict): A dictionary mapping attribute names to tuples containing attribute display names
+                           and their expected types.
+            **kwargs: Additional keyword arguments for initializing attributes.
+
+        Attributes:
+            __fields (dict): Stores the fields dictionary passed during initialization.
+        """
+        self.__fields = fields
+        for key, (_, field_type) in self.__fields.items():
+            # 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:
+        """
+        Sets the value of an attribute and verifies its type.
+
+        Args:
+            key (str): The name of the attribute to set.
+            value (any): The value to assign to the attribute.
+
+        Raises:
+            TypeError: If the assigned value does not match the expected type for the attribute.
+        """
+        try:
+            field_type = self.__fields[key][1]
+            # Convert value to the specified type if necessary
+            if field_type not in (int, str, bool):
+                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)
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the object.
+
+        Returns:
+            str: A string representation of the object, displaying its class name and attribute key-value pairs.
+        """
+        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("_")
+                ]
+            ),
+        )
+
+
+class ComicModel(BaseModel):
+    """
+    Model for representing comic book metadata.
+    """
+
+    title: str
+    series: str
+    number: float
+    count: int
+    volume: int
+    alternate_series: str
+    alternate_number: int
+    alternate_count: int
+    summary: str
+    notes: str
+    year: int
+    month: int
+    day: int
+    writer: str
+    penciller: str
+    inker: str
+    colorist: str
+    letterer: str
+    cover_artist: str
+    editor: str
+    translator: str
+    publisher: str
+    imprint: str
+    genre: str
+    tags: str
+    web: str
+    format: Format
+    ean: str
+    black_white: YesNo
+    manga: Manga
+    characters: str
+    teams: str
+    locations: str
+    scan_information: str
+    story_arc: str
+    story_arc_number: int
+    series_group: str
+    age_rating: AgeRating
+    main_character_or_team: str
+    review: str
+    language_iso: LanguageISO
+    community_rating: Rating
+    added: str
+    released: str
+    file_size: int
+    file_modified_time: str
+    file_creation_time: str
+    book_price: str
+    custom_values_store: str
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a ComicModel instance.
+
+        Args:
+            **kwargs: Keyword arguments used to initialize attributes of the ComicModel.
+        """
+        super(ComicModel, self).__init__(COMIC_FIELDS, **kwargs)
+
+
+class PageModel(BaseModel):
+    """
+    Model for representing comic book pages.
+    """
+
+    type: PageType
+    double: bool
+    image_size: int
+    key: str
+    bookmark: str
+    image_width: int
+    image_height: int
+    suffix: str
+    name: str
+    __content: bytes
+
+    def __init__(self, **kwargs):
+        """
+        Initializes a PageModel instance.
+
+        Args:
+            **kwargs: Keyword arguments used to initialize attributes of the PageModel.
+        """
+        super(PageModel, self).__init__(PAGE_FIELDS, **kwargs)

cbz/page.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import base64
+
+from io import BytesIO
+from typing import Union, Optional
+from pathlib import Path
+
+from PIL import Image
+
+from cbz.constants import IMAGE_FORMAT
+from cbz.models import PageModel
+
+
+class PageInfo(PageModel):
+    """
+    Model for representing comic book pages with additional content handling capabilities.
+    """
+
+    def __init__(self, content: bytes, name: Optional[str] = None, **kwargs):
+        """
+        Initializes a PageInfo instance.
+
+        Args:
+            content (bytes): The content of the page in bytes.
+            name (Optional[str]): The name of the page (default is None).
+            **kwargs: Additional keyword arguments passed to the base class initializer.
+        """
+        super(PageInfo, self).__init__(**kwargs)
+        self.name = name
+        self.content = content
+
+    @property
+    def content(self) -> bytes:
+        """
+       Getter property for the content of the page.
+
+       Returns:
+           bytes: The content of the page.
+       """
+        return self.__content
+
+    @content.setter
+    def content(self, value: bytes) -> None:
+        """
+        Setter property for the content of the page. Automatically extracts image metadata.
+
+        Args:
+            value (bytes): The content of the page in bytes.
+        """
+        with Image.open(BytesIO(value)) as f:
+            self.suffix = f'.{f.format.lower()}'
+            assert self.suffix in IMAGE_FORMAT, f'Unsupported image format: {self.suffix}'
+            self.image_width = int(f.width)
+            self.image_height = int(f.height)
+        self.image_size = len(value)
+        self.__content = value
+
+    @classmethod
+    def loads(cls, data: Union[str, bytes], **kwargs) -> PageInfo:
+        """
+        Class method to create a PageInfo instance from bytes or base64-encoded data.
+
+        Args:
+            data (Union[str, bytes]): The data representing the page content.
+            **kwargs: Additional keyword arguments passed to the PageInfo initializer.
+
+        Returns:
+            PageInfo: The created PageInfo instance.
+
+        Raises:
+            ValueError: If the data type is neither str nor bytes.
+        """
+        if isinstance(data, str):
+            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
+    def load(cls, path: Union[Path, str], **kwargs) -> PageInfo:
+        """
+        Class method to create a PageInfo instance from a file path.
+
+        Args:
+            path (Union[Path, str]): The path to the file containing the page content.
+            **kwargs: Additional keyword arguments passed to the PageInfo initializer.
+
+        Returns:
+            PageInfo: The created PageInfo instance.
+
+        Raises:
+            ValueError: If the path type is neither Path nor str.
+            FileNotFoundError: If the specified file path does not exist.
+        """
+        if not isinstance(path, (Path, str)):
+            raise ValueError(f'Expecting Path object or path string, got {path!r}')
+        path = Path(path)
+        with path.open(mode='rb') as f:
+            kwargs.setdefault('name', path.name)
+            return cls.loads(f.read(), **kwargs)
+
+    def show(self) -> None:
+        """
+        Displays the page content using an image viewer.
+        """
+        with Image.open(BytesIO(self.content)) as f:
+            f.show()
+
+    def save(self, path: Union[Path, str]) -> None:
+        """
+        Saves the page content to a file.
+
+        Args:
+            path (Union[Path, str]): The path where the content should be saved.
+        """
+        with Path(path).open(mode='wb') as f:
+            f.write(self.content)

cbz/player.py

@@ -0,0 +1,423 @@
+import os
+import tkinter as tk
+
+from io import BytesIO
+from tkinter import ttk
+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
+from cbz.page import PageInfo
+from cbz.utils import readable_size, ico_to_png
+
+PARENT = Path(__file__).parent
+CTRL_KEY = 0x4  # Constant for Ctrl key
+
+
+class Player:
+    """
+    A simple comic book player application using Tkinter.
+
+    This class initializes a graphical user interface (GUI) using Tkinter
+    to display comic book pages (either as images or summaries). It supports
+    navigation between pages, window resizing, and basic comic book information
+    display.
+
+    Attributes:
+        comic_info (ComicInfo): Object containing comic book information.
+        current_page (int): Index of the currently displayed page (-1 for summary).
+        root (tk.Tk): Tkinter root window instance.
+        main_frame (ttk.Frame): Frame for holding main content.
+        canvas (tk.Canvas): Canvas for displaying comic book pages.
+        prev_button (ttk.Button): Button for navigating to the previous page.
+        next_button (ttk.Button): Button for navigating to the next page.
+        summary_text (tk.Text): Text widget for displaying comic book information summary.
+        page_index_label (ttk.Label): Label showing the current page index.
+        previous_width (int): Previous width of the main window.
+        previous_height (int): Previous height of the main window.
+        resize_timer (int or None): Timer ID for handling window resize delay.
+        max_zoom_factor (float or None): Maximum allowable zoom factor based on canvas size and image dimensions.
+        zoom_factor (float or None): Current zoom factor for image display.
+        img_original (PIL.Image.Image or None): Placeholder for the original image to be displayed.
+    """
+
+    def __init__(self, comic_info: ComicInfo):
+        """
+        Initialize the comic player with the given ComicInfo object.
+
+        Args:
+            comic_info (ComicInfo): Object containing comic book information.
+        """
+        self.comic_info = comic_info
+        self.current_page = -1  # Track the current page index
+        self.max_zoom_factor = None  # Maximum allowable zoom factor based on canvas size and image dimensions
+        self.zoom_factor = None  # Initial zoom factor (None means no zoom initially)
+        self.img_original = None  # Placeholder for the original image
+
+        # Initialize tkinter window
+        self.root = tk.Tk()
+        self.root.title(self._get_window_title())
+
+        # Set initial window size
+        self.root.geometry(self._get_initial_geometry())
+
+        # Set the application icon
+        self._set_icon()
+
+        # Create main frame for content
+        self.main_frame = ttk.Frame(self.root)
+        self.main_frame.pack(fill=tk.BOTH, expand=True)
+
+        # Create canvas for displaying pages
+        self.canvas = tk.Canvas(self.main_frame, bg='white')
+        self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+
+        # Create navigation buttons
+        self._create_buttons()
+
+        # Initialize text widget for the summary page
+        self._init_summary_text()
+
+        # Display initial page content
+        self.show_page()
+
+        # Bind keys for navigation and window resize
+        self._bind_keys()
+
+        # Initialize the previous window size
+        self.previous_width = self.root.winfo_width()
+        self.previous_height = self.root.winfo_height()
+
+        # Initialize resize timer
+        self.resize_timer = None
+
+    def _set_icon(self) -> None:
+        """
+        Set the application icon for the window.
+        """
+        image_path = PARENT / 'cbz.ico'
+        if os.name == 'nt':
+            # Set the application ID and icon on Windows
+            windll.shell32.SetCurrentProcessExplicitAppUserModelID('cbz.player')
+            self.root.iconbitmap(image_path)
+        else:
+            # Convert ICO to PNG for other operating systems
+            image = ico_to_png(image_path)
+            self.root.iconphoto(True, tk.PhotoImage(data=image.getvalue()))
+
+    def _get_window_title(self) -> str:
+        """
+        Get the window title based on the comic series and title.
+
+        Returns:
+            str: Window title.
+        """
+        if self.comic_info.series and self.comic_info.title:
+            return f'{self.comic_info.series} - {self.comic_info.title}'
+        return self.comic_info.title or self.__class__.__name__
+
+    def _get_initial_geometry(self) -> str:
+        """
+        Calculate the initial window size and position based on the first page of the comic or default screen size.
+
+        Returns:
+            str: Initial window geometry string in the format 'widthxheight+x_position+y_position'.
+        """
+        # Determine initial window size based on first page or default
+        margin_width = self.root.winfo_screenwidth() * 0.1
+        margin_height = self.root.winfo_screenheight() * 0.1
+
+        # Calculate available space after margins
+        available_width = self.root.winfo_screenwidth() - 2 * margin_width
+        available_height = self.root.winfo_screenheight() - 2 * margin_height
+
+        # Default screen size for initialization
+        screen_width = int(available_height * 0.63)
+        screen_height = int(available_height)
+
+        # Calculate scaling factors for width and height
+        if self.comic_info.pages:
+            # Get the minimum dimensions from all pages
+            image_width = self.comic_info.pages[0].image_width
+            image_height = self.comic_info.pages[0].image_height
+            for page in self.comic_info.pages[1:]:
+                if page.image_width <= image_width and page.image_height <= image_height:
+                    image_width = page.image_width
+                    image_height = page.image_height
+
+            scale_width = available_width / image_width
+            scale_height = available_height / image_height
+
+            # Choose the smaller scaling factor to maintain proportions
+            scale_factor = min(scale_width, scale_height)
+
+            # Calculate new dimensions
+            initial_width = int(image_width * scale_factor * 0.94)
+            initial_height = int(image_height * scale_factor)
+        else:
+            # If no pages are available, default to screen size
+            initial_width = screen_width
+            initial_height = screen_height
+
+        # Ensure that the window's initial width is at least 50% of the screen width
+        if 100 / screen_width * initial_width < 50.0:
+            initial_width = screen_width
+
+        # Calculate initial position to center the window on the screen
+        x = self.root.winfo_screenwidth() // 2 - initial_width // 2
+        y = self.root.winfo_screenheight() // 2 - initial_height // 2
+
+        return f'{initial_width}x{initial_height}+{x}+{y}'
+
+    def _create_buttons(self) -> None:
+        """
+        Create navigation buttons for previous, next, and exit operations.
+        """
+        # Create button frame
+        button_frame = ttk.Frame(self.main_frame, height=10)
+        button_frame.pack(side=tk.BOTTOM, pady=10)
+
+        # Previous page button
+        self.prev_button = ttk.Button(button_frame, text='Previous', command=self.on_previous)
+        self.prev_button.pack(side=tk.LEFT, padx=10)
+
+        # Page index label
+        self.page_index_label = ttk.Label(button_frame, text=f'{self.current_page + 1}/{len(self.comic_info.pages)}')
+        self.page_index_label.pack(side=tk.LEFT, padx=10)
+
+        # Next page button
+        self.next_button = ttk.Button(button_frame, text='Next', command=self.one_next)
+        self.next_button.pack(side=tk.LEFT, padx=10)
+
+        # Exit button (optional)
+        exit_button = ttk.Button(button_frame, text='Exit', command=self.root.quit)
+        exit_button.pack(side=tk.RIGHT, padx=10)
+
+    def _init_summary_text(self) -> None:
+        """
+        Initialize the summary text widget for displaying comic information.
+        """
+        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=tk.DISABLED)
+
+    def show_page(self) -> None:
+        """
+        Display the current page content (either summary or image).
+        """
+        # Clear previous content on canvas
+        self.canvas.delete('all')
+
+        # Display page content
+        if self.current_page == -1:
+            self._show_summary_page()
+        elif self.current_page < len(self.comic_info.pages):
+            self._show_image_page()
+
+        # Update navigation button states based on current page index
+        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)}')
+
+    def _show_summary_page(self) -> None:
+        """
+        Display the summary page with comic information.
+        """
+        # Use update_idletasks to ensure window size is updated before using it
+        self.root.update_idletasks()
+
+        # Display summary for the first page
+        infos = self.comic_info.get_info()
+
+        self.summary_text.config(state=tk.NORMAL)
+        self.summary_text.delete('1.0', tk.END)
+
+        for key, value in infos.items():
+            if not (key.startswith('@') or key == 'Pages'):
+                if key == 'FileSize':
+                    value = readable_size(value)
+                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=tk.DISABLED)
+        self.summary_text.place(relwidth=1, relheight=1)
+
+    def _show_image_page(self) -> None:
+        """
+        Display the image page centered on the canvas.
+        """
+        # Hide the summary text widget
+        self.summary_text.place_forget()
+
+        # Display image centered on canvas
+        page: PageInfo = self.comic_info.pages[self.current_page]
+        self.img_original = Image.open(BytesIO(page.content))
+        self._display_image()
+
+    def _display_image(self) -> None:
+        """
+        Display the image on the canvas with zooming capabilities.
+        """
+        # Check if zoom factor is not set; initialize zoom factors
+        if not self.zoom_factor:
+            # Determine maximum zoom factor based on canvas size and original image size
+            self.max_zoom_factor = min(
+                self.canvas.winfo_width() / self.img_original.width,
+                self.canvas.winfo_height() / self.img_original.height
+            )
+            self.zoom_factor = self.max_zoom_factor
+
+        # Calculate new dimensions of the image based on current zoom factor
+        new_width = int(self.img_original.width * self.zoom_factor)
+        new_height = int(self.img_original.height * self.zoom_factor)
+        img = self.img_original.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+        # Convert the resized image to PhotoImage format compatible with Tkinter canvas
+        self.canvas.image = ImageTk.PhotoImage(img)
+
+        # Calculate the position to center the image on the canvas
+        x = max(0, (self.canvas.winfo_width() - new_width) // 2)
+        y = max(0, (self.canvas.winfo_height() - new_height) // 2)
+        self.canvas.create_image(x, y, anchor=tk.NW, image=self.canvas.image)
+
+        # Configure the scroll region of the canvas to allow scrolling if image is larger than canvas
+        canvas_width = max(new_width, self.canvas.winfo_width())
+        canvas_height = max(new_height, self.canvas.winfo_height())
+        self.canvas.config(scrollregion=(0, 0, canvas_width, canvas_height))
+
+    def _bind_keys(self) -> None:
+        """
+        Bind keys for navigation (left/right arrow keys) and window events.
+        """
+        # Bind arrow keys for navigation
+        self.root.bind('<Left>', lambda event: self.on_previous())
+        self.root.bind('<Right>', lambda event: self.one_next())
+
+        # Bind Ctrl+Q to exit application
+        self.root.bind('<Control-q>', lambda event: self.root.quit())
+        # Bind the configure event to handle window resize
+        self.root.bind('<Configure>', lambda event: self.on_window(event))
+
+        # Bind mouse wheel events for zooming
+        self.root.bind('<Control-MouseWheel>', self.on_zoom)
+        self.canvas.bind_all("<MouseWheel>", self._on_mouse_wheel)
+        self.canvas.bind_all("<Shift-MouseWheel>", self._on_shift_mouse_wheel)
+
+        # Bind zoom controls to keyboard keys
+        self.root.bind('<KeyPress-plus>', lambda event: self.on_zoom_key(True))
+        self.root.bind('<KeyPress-minus>', lambda event: self.on_zoom_key(False))
+
+    def on_zoom_key(self, positive: bool) -> None:
+        """
+        Handle zooming triggered by keyboard keys ('+' for zoom in, '-' for zoom out).
+
+        Args:
+            positive (bool): True for zoom in, False for zoom out.
+        """
+        # Create a synthetic event object to simulate mouse wheel scrolling
+        event = tk.Event()
+        event.delta = 120 if positive else -120
+        self.on_zoom(event)
+
+    def on_zoom(self, event) -> None:
+        """
+        Handle zooming using Ctrl + Mouse Wheel.
+        """
+        if self.current_page == -1: return
+
+        # Adjust zoom factor based on mouse wheel direction
+        if event.delta > 0:
+            # Increase zoom factor by 10% for zoom in
+            self.zoom_factor *= 1.1
+        elif event.delta < 0:
+            # Decrease zoom factor by 10% for zoom out
+            self.zoom_factor /= 1.1
+
+        # Ensure the zoom-out factor doesn't go below the original image size
+        min_zoom_factor = min(
+            self.canvas.winfo_width() / self.img_original.width,
+            self.canvas.winfo_height() / self.img_original.height
+        )
+
+        if self.zoom_factor < min_zoom_factor:
+            self.zoom_factor = min_zoom_factor
+
+        # Update the displayed image with the new zoom factor
+        self._display_image()
+
+    def _on_mouse_wheel(self, event) -> None:
+        """
+        Handle vertical scroll using Mouse Wheel.
+        """
+        if self.current_page == -1 or (event.state & CTRL_KEY): return
+        self.canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
+
+    def _on_shift_mouse_wheel(self, event) -> None:
+        """
+        Handle horizontal scroll using Shift + Mouse Wheel.
+        """
+        if self.current_page == -1 or (event.state & CTRL_KEY): return
+        self.canvas.xview_scroll(int(-1 * (event.delta / 120)), "units")
+
+    def on_previous(self) -> None:
+        """
+        Navigate to the previous page.
+        """
+        if self.current_page == -1: return
+        self.current_page -= 1
+        self.show_page()
+
+    def one_next(self) -> None:
+        """
+        Navigate to the next page.
+        """
+        if self.current_page < len(self.comic_info.pages) - 1:
+            self.current_page += 1
+            self.show_page()
+
+    def on_window(self, event: any) -> None:
+        """
+        Handle window resize event.
+        """
+        # Check if width or height has changed
+        if event.width != self.previous_width or event.height != self.previous_height:
+            self.previous_width = event.width
+            self.previous_height = event.height
+
+            # Cancel any existing resize timer
+            if self.resize_timer:
+                self.root.after_cancel(self.resize_timer)
+
+            # Set a new timer to call show_page after a delay
+            self.resize_timer = self.root.after(200, self._on_resize)
+
+    def _on_resize(self) -> None:
+        """
+        Handle resizing of the window and adjust image display accordingly.
+        """
+        if self.current_page == -1: return
+
+        # Reset zoom factor to None if it's equal to the maximum zoom factor
+        if self.zoom_factor == self.max_zoom_factor:
+            self.zoom_factor = None
+
+        # Update the displayed image with the current zoom factor
+        self._display_image()
+
+        # Reset the resize timer
+        self.resize_timer = None
+
+    def run(self) -> None:
+        """
+        Run the comic player application.
+        """
+        self.root.mainloop()

cbz/utils.py

@@ -0,0 +1,109 @@
+from enum import Enum
+from io import BytesIO
+from pathlib import Path
+
+from PIL import Image
+from PIL.IcoImagePlugin import IcoFile
+
+
+def default_attr(value: any) -> any:
+    """
+    Provides a default value based on the expected type of attribute.
+
+    Args:
+        value (any): Expected type or class of the attribute.
+
+    Returns:
+        any: Default value appropriate for the specified type or class.
+            - For Enum types: Returns the 'UNKNOWN' member if available, otherwise the first member.
+            - For int or float: Returns -1.
+            - For bool: Returns False.
+            - For str: Returns an empty string.
+            - For other types: Invokes the callable (assuming it's a function or callable object).
+    """
+    if issubclass(value, Enum):
+        keys = [i.name for i in list(value)]
+        return value['UNKNOWN' if 'UNKNOWN' in keys else 'STORY']
+    elif value in (int, float):
+        return -1
+    elif value == bool:
+        return False
+    elif value == str:
+        return ''
+    else:
+        return value()
+
+
+def verify_attr(expected_type: any, key: str, value: any) -> None:
+    """
+    Verifies if the provided value matches the expected type.
+
+    Args:
+        expected_type (any): Expected type of the attribute.
+        key (str): Name of the attribute.
+        value (any): Value to be verified against the expected type.
+
+    Raises:
+        TypeError: If the provided value does not match the expected type.
+    """
+    if not isinstance(value, expected_type):
+        raise TypeError(f'Expected type {expected_type} for attribute "{key}", but got {type(value)}')
+
+
+def repr_attr(value: any) -> any:
+    """
+    Provides a representation of the attribute's value.
+
+    Args:
+        value (any): Value of the attribute.
+
+    Returns:
+        any: Representation of the attribute's value.
+            - For Enum types: Returns the value of the Enum.
+            - For other types: Returns the value itself.
+    """
+    if isinstance(value, Enum):
+        return value.value
+    return value
+
+
+def readable_size(size: int, decimal: int = 2) -> str:
+    """
+    Converts a file size in bytes to a human-readable string format.
+
+    Args:
+        size (int): The size in bytes.
+        decimal (int): Number of decimal places to display (default is 2).
+
+    Returns:
+        str: Human-readable string representation of the size.
+    """
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size < 1024:
+            return f'{size:.{decimal}f} {unit}'
+        size /= 1024
+
+
+def ico_to_png(path: Path) -> BytesIO:
+    """
+    Converts the largest icon in an ICO file to PNG format.
+
+    Args:
+       path (Path): Path to the ICO file.
+
+    Returns:
+       BytesIO: In-memory PNG file of the largest icon.
+    """
+    # Open the ICO file and read its content
+    image = Image.open(BytesIO(path.read_bytes()))
+    assert image.format == 'ICO', 'Unsupported image format'
+
+    # Get the ICO file object and find the largest icon size
+    icon: IcoFile = image.ico
+    max_size = max(icon.sizes(), key=lambda x: x[0] + x[1])
+    largest_image = icon.getimage(size=max_size)
+
+    # Save the largest icon as PNG format to an in-memory BytesIO object
+    content = BytesIO()
+    largest_image.save(content, format='PNG')
+    return content

docs/favicon/favicon.svg

@@ -0,0 +1,51 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512" viewBox="0 0 512 512">
+  <defs>
+    <clipPath id="clip-favicon">
+      <rect width="512" height="512"/>
+    </clipPath>
+  </defs>
+  <g id="favicon" clip-path="url(#clip-favicon)">
+    <g id="clipboard" transform="translate(-23.514 -24.026)">
+      <g id="_000000ff" data-name="#000000ff" transform="translate(23.966 24.026)">
+        <path id="Path_1" data-name="Path 1" d="M169.389,31.663c.738-3.359,3.051-6.52,6.531-7.335,4.846-1.377,8.954,2.28,12.808,4.6,43.612,29.3,76.068,74.56,90.341,125.088.363,1.817,1.278-.463,1.333-1.046,8.733-27.819,26.068-52.313,47.1-72.225,24.086-22.775,52.72-40.4,83.073-53.491,3.579-1.344,7.148-3.491,11.1-3.15a8.832,8.832,0,0,1,7.511,7.577c1.6,8.767,2.963,17.588,4.5,26.366,15.154-5.4,30.3-10.87,45.573-15.914a8.733,8.733,0,0,1,10.87,4.692c4.78,10.628,9.251,21.41,13.976,32.071,5.991-3.106,11.861-6.454,17.885-9.493a8.785,8.785,0,0,1,11.267,2.5c1.6,2,1.718,4.648,1.762,7.093q-.033,159.185-.011,318.381c-.066,4.053.275,8.128-.275,12.159-.562,3.227-3.315,5.374-6.046,6.806Q429.13,469.256,329.709,522.4c-6.806,3.557-13.447,7.632-20.9,9.747a112.762,112.762,0,0,1-36.465,3.7c-11.322-.7-22.819-2.742-32.93-8.117q-102.72-54.7-205.43-109.482c-3.392-1.927-7.72-3.348-9.273-7.291-1.09-3.293-.628-6.839-.727-10.242q.1-161.415.044-322.842a8.992,8.992,0,0,1,5.33-8.844c2.941-1.388,6.322-.518,9.009,1.024,7.709,4.108,15.4,8.249,23.117,12.335,2.357-11.366,4.427-22.8,6.916-34.141.98-4.692,6.156-7.544,10.716-6.377,28.051,4.5,54.736,15.1,80.121,27.61q5.039-18.932,10.154-37.819M360.546,75.5c-19.714,14.736-37.8,32.4-50.176,53.844,30.143-29.229,67.7-49.5,106.509-64.758-.991-6.52-2.225-13-3.2-19.515A266.629,266.629,0,0,0,360.546,75.5M175.1,78.259C204.686,95.352,231.68,116.685,256,140.638c-14.482-37.236-39.615-70.661-72.39-93.656-3.018,10.374-5.628,20.87-8.5,31.278M83.761,60.616C81.845,70.782,79.719,80.9,77.737,91.057,134.059,120.947,190.259,151.09,246.57,181c8.48,3.106,17.632,3.976,26.575,4.725C237.4,142.268,193.211,105.088,142.164,80.9c-18.678-8.756-38.161-16.09-58.4-20.286m293.745,41.575a255.536,255.536,0,0,0-91.564,83.557c9.1-.848,18.447-1.674,27.037-4.945q87.737-46.867,175.529-93.59-5.617-12.885-11.178-25.782c-34.009,11.608-68.282,23.271-99.824,40.76M41.636,91.784c.055,103.579-.154,207.148.1,310.727q3.948,1.949,7.83,4.053c5.551,3.172,11.222,6.167,16.938,9.031v.165c1.905.98,3.811,1.971,5.694,2.974q81.608,43.563,163.238,87.06.05-152.66,0-305.32c-.011-1.828-.022-3.656-.044-5.474Q138.469,143.458,41.636,91.784M323.629,195.022c-.066,3.2-.077,6.4-.066,9.6q.033,150.595.022,301.2,93.866-49.84,187.577-99.945l-.055-.385c2.048-.936,4.1-1.905,6.156-2.852.308-103.6.044-207.225.132-310.837q-96.889,51.608-193.767,103.216m-70.507,5.991q-.1,137.049.011,274.1c12.974,1.806,26.178,2.654,39.251,1.355a119.414,119.414,0,0,0,13.557-1.586q-.017-137,0-274c-.925.187-2.753.551-3.667.738-12.148,1.6-24.416,2.533-36.652,1.289v-.33c-1.949-.154-3.9-.319-5.848-.485-2.225-.319-4.438-.694-6.652-1.079m-.033,291.74q-.033,11.085.011,22.17c2.709.793,5.441,1.531,8.15,2.346l4.284.661c10.385,1.189,21.1,1.4,31.344-.936a73.568,73.568,0,0,0,8.965-2.1c.2-7.357.055-14.714.1-22.059-4.042.352-8.106.584-12.1,1.311A214.472,214.472,0,0,1,253.09,492.753Z" transform="translate(-23.966 -24.026)"/>
+        <path id="Path_2" data-name="Path 2" d="M457.7,142.458c5.264-3.128,12.742,1.057,12.786,7.181.242,18.018.066,36.046.088,54.064a9.319,9.319,0,0,1-5.507,8.756q-67.318,35.7-134.659,71.322c-3.095,1.542-6.09,3.733-9.659,3.855a8.814,8.814,0,0,1-8.689-8.855c-.121-17.7-.044-35.4-.033-53.095a9.162,9.162,0,0,1,5.253-8.932q70.209-37.153,140.419-74.3M329.611,230.167c.011,1.476.011,2.941.022,4.416-.033,9.945,0,19.89-.011,29.824Q388.8,233.1,447.937,201.731c1.641-.947,3.3-1.839,4.978-2.72.121-11.388.022-22.775.055-34.163Q391.3,197.524,329.611,230.167Z" transform="translate(5.217 -12.134)"/>
+        <path id="Path_3" data-name="Path 3" d="M253.906,212.509c5.419-2.148,11.905,2.445,11.663,8.271.132,53.954.022,107.919.055,161.883.374,4.251-2.313,8.623-6.564,9.637-5.308,1.619-11.245-2.918-11-8.469-.121-54-.022-108-.055-161.993A9.061,9.061,0,0,1,253.906,212.509Z" transform="translate(-1.269 -4.983)"/>
+        <path id="Path_4" data-name="Path 4" d="M253.861,384.521c5.408-2.17,11.916,2.39,11.707,8.2.143,8.48.033,16.971.044,25.463a9.075,9.075,0,0,1-5.892,9.35c-5.374,2.137-11.861-2.39-11.652-8.172q-.182-13.315-.011-26.641A8.733,8.733,0,0,1,253.861,384.521Z" transform="translate(-1.268 12.444)"/>
+      </g>
+      <g id="_fcf3e7ff" data-name="#fcf3e7ff" transform="translate(77.737 45.066)">
+        <path id="Path_5" data-name="Path 5" d="M334.2,73.56a266.629,266.629,0,0,1,53.128-30.43c.98,6.52,2.214,13,3.2,19.515C351.718,77.9,314.163,98.174,284.02,127.4,296.4,105.96,314.483,88.3,334.2,73.56Z" transform="translate(-51.388 -43.13)" fill="#fcf3e7"/>
+        <path id="Path_6" data-name="Path 6" d="M161.2,76.148c2.874-10.407,5.485-20.9,8.5-31.278,32.775,23,57.908,56.421,72.39,93.656C217.775,114.573,190.782,93.24,161.2,76.148Z" transform="translate(-63.832 -42.954)" fill="#fcf3e7"/>
+        <path id="Path_7" data-name="Path 7" d="M78.814,57.25c20.242,4.2,39.725,11.531,58.4,20.286C188.264,101.721,232.449,138.9,268.2,182.36c-8.943-.749-18.095-1.619-26.575-4.725C185.312,147.724,129.112,117.58,72.79,87.691,74.772,77.536,76.9,67.415,78.814,57.25Z" transform="translate(-72.79 -41.699)" fill="#fcf3e7"/>
+        <path id="Path_8" data-name="Path 8" d="M353.4,98.75c31.542-17.489,65.815-29.152,99.824-40.76q5.551,12.9,11.178,25.782-87.7,46.9-175.529,93.59c-8.59,3.271-17.941,4.1-27.037,4.945A255.536,255.536,0,0,1,353.4,98.75Z" transform="translate(-53.635 -41.624)" fill="#fcf3e7"/>
+      </g>
+      <g id="_c68315ff" data-name="#c68315ff" transform="translate(41.606 91.784)">
+        <path id="Path_9" data-name="Path 9" d="M40.013,85.55q96.905,51.542,193.756,103.216c.022,1.817.033,3.645.044,5.474-7.2-3.414-14.152-7.335-21.2-11.057-47.2-25.242-94.5-50.286-141.707-75.54q-2.874-1.569-5.782-3.073c-5.595-2.919-11.1-6.013-16.751-8.822-.3,5.573-.319,11.156-.231,16.729q.05,115.655.011,231.289c-.132,18.855.275,37.72-.209,56.564q-3.882-2.1-7.83-4.053C39.859,292.7,40.068,189.129,40.013,85.55Z" transform="translate(-39.983 -85.55)" fill="#c68315"/>
+      </g>
+      <g id="_e2910dff" data-name="#e2910dff" transform="translate(292.385 91.806)">
+        <path id="Path_10" data-name="Path 10" d="M296.066,188.786Q393.021,137.31,489.833,85.57c-.088,103.612.176,207.236-.132,310.837-2.059.947-4.108,1.916-6.156,2.852-.3-1.971-.584-3.954-.7-5.936q0-147.093.011-294.218a127.8,127.8,0,0,0-14.394,7.291C411,137.112,353.379,167.53,296,198.389,295.989,195.185,296,191.991,296.066,188.786Z" transform="translate(-264.822 -85.57)" fill="#e2910d"/>
+        <path id="Path_11" data-name="Path 11" d="M277.58,185.348c.914-.187,2.742-.551,3.667-.738q.017,137,0,274a119.414,119.414,0,0,1-13.557,1.586c2.709-.529,5.385-1.255,8.073-1.916q.2-128.921.055-257.842C276,195.414,274.849,189.907,277.58,185.348Z" transform="translate(-267.69 -75.535)" fill="#e2910d"/>
+        <path id="Path_12" data-name="Path 12" d="M269.01,451.011c4-.727,8.062-.958,12.1-1.311-.044,7.346.1,14.7-.1,22.06a73.568,73.568,0,0,1-8.965,2.1c1.211-.9,2.4-1.839,3.579-2.775.1-6.729.143-13.458-.077-20.187C273.371,450.922,271.191,450.944,269.01,451.011Z" transform="translate(-267.556 -48.675)" fill="#e2910d"/>
+      </g>
+      <g id="_f8a928ff" data-name="#f8a928ff" transform="translate(49.565 101.982)">
+        <path id="Path_13" data-name="Path 13" d="M47.408,111.539c-.088-5.573-.066-11.156.231-16.729,5.65,2.808,11.156,5.9,16.751,8.822-.43,46.685-.055,93.37-.176,140.055-.033,54.912.055,109.824-.066,164.736-5.716-2.863-11.388-5.859-16.938-9.031.485-18.844.077-37.709.209-56.564Q47.4,227.189,47.408,111.539Z" transform="translate(-47.21 -94.81)" fill="#f8a928"/>
+        <path id="Path_14" data-name="Path 14" d="M468.456,105.151a127.8,127.8,0,0,1,14.394-7.291q-.05,147.109-.011,294.218c.121,1.982.408,3.965.7,5.936l.055.385q-93.833,49.873-187.577,99.945-.083-150.611-.022-301.2c57.379-30.859,115-61.278,172.456-91.993m-9.141,41.718q-70.242,37.071-140.419,74.3a9.162,9.162,0,0,0-5.253,8.932c-.011,17.7-.088,35.4.033,53.095a8.814,8.814,0,0,0,8.689,8.855c3.568-.121,6.564-2.313,9.659-3.855q67.318-35.65,134.659-71.322a9.319,9.319,0,0,0,5.507-8.756c-.022-18.018.154-36.046-.088-54.064C472.058,147.926,464.58,143.741,459.315,146.869Z" transform="translate(-22.002 -94.501)" fill="#f8a928"/>
+        <path id="Path_15" data-name="Path 15" d="M68.09,105.61c47.2,25.253,94.5,50.3,141.707,75.54,7.048,3.722,14,7.643,21.2,11.057q.066,152.66,0,305.32-81.625-43.5-163.238-87.06c.231-64.02.022-128.04.1-192.06C68.024,180.808,67.573,143.2,68.09,105.61Z" transform="translate(-45.128 -93.716)" fill="#f8a928"/>
+        <path id="Path_16" data-name="Path 16" d="M232.045,184.73c2.214.385,4.427.76,6.652,1.079.22,91.134.055,182.269.1,273.4,1.861.132,3.711.253,5.573.374.363-90.98.044-181.971.176-272.963,12.236,1.244,24.5.308,36.652-1.289-2.731,4.559-1.575,10.066-1.762,15.088q-.033,128.921-.055,257.842c-2.687.661-5.363,1.388-8.073,1.916-13.073,1.3-26.278.452-39.251-1.355q-.149-137.049-.011-274.1m23.48,30.54a9.061,9.061,0,0,0-5.9,9.328c.033,54-.066,108,.055,161.994-.242,5.551,5.694,10.088,11,8.469,4.251-1.013,6.938-5.385,6.564-9.637-.033-53.965.077-107.93-.055-161.883.242-5.826-6.245-10.419-11.663-8.271m-.044,189.438a8.733,8.733,0,0,0-5.8,8.2q-.165,13.315.011,26.641c-.209,5.782,6.278,10.308,11.652,8.172a9.075,9.075,0,0,0,5.892-9.35c-.011-8.491.1-16.982-.044-25.463C267.4,407.1,260.889,402.539,255.481,404.708Z" transform="translate(-28.488 -85.699)" fill="#f8a928"/>
+        <path id="Path_17" data-name="Path 17" d="M232.011,449.63a214.472,214.472,0,0,0,40.749,1.388c2.181-.066,4.361-.088,6.542-.11.22,6.729.176,13.458.077,20.187-1.178.936-2.368,1.872-3.579,2.775-10.242,2.335-20.958,2.126-31.344.936.066-7.775.407-15.573-.363-23.326-1.652-.319-3.293-.65-4.934-.969-.4,6.09-.573,12.2-.374,18.3a12.568,12.568,0,0,0,1.388,5.33c-2.709-.815-5.441-1.553-8.15-2.346Q231.973,460.715,232.011,449.63Z" transform="translate(-28.487 -58.859)" fill="#f8a928"/>
+      </g>
+      <g id="_fabf5dff" data-name="#fabf5dff" transform="translate(66.504 110.804)">
+        <path id="Path_18" data-name="Path 18" d="M62.832,102.82q2.907,1.5,5.782,3.073c-.518,37.588-.066,75.2-.231,112.8-.077,64.02.132,128.04-.1,192.06-1.883-1-3.789-1.993-5.694-2.974v-.165c.121-54.912.033-109.824.066-164.736C62.777,196.19,62.4,149.505,62.832,102.82Z" transform="translate(-62.59 -102.82)" fill="#fabf5d"/>
+      </g>
+      <g id="_d9d9d9ff" data-name="#d9d9d9ff" transform="translate(358.794 176.74)">
+        <path id="Path_19" data-name="Path 19" d="M327.99,228.009q61.669-32.676,123.359-65.319c-.033,11.388.066,22.775-.055,34.163-1.674.881-3.337,1.773-4.978,2.72-.154-9.78.187-19.559-.2-29.328-39.515,20.441-78.557,41.8-118.106,62.181C328,230.95,328,229.485,327.99,228.009Z" transform="translate(-327.99 -162.69)" fill="#d9d9d9"/>
+      </g>
+      <g id="_ffffffff" data-name="#ffffffff" transform="translate(358.801 184.295)">
+        <path id="Path_20" data-name="Path 20" d="M328.011,231.731c39.548-20.385,78.59-41.74,118.106-62.181.385,9.769.044,19.548.2,29.328Q387.241,230.365,328,261.554C328.011,251.621,327.978,241.676,328.011,231.731Z" transform="translate(-327.996 -169.55)" fill="#fff"/>
+      </g>
+      <g id="_f8ba55ff" data-name="#f8ba55ff" transform="translate(259.775 202.092)">
+        <path id="Path_21" data-name="Path 21" d="M238.08,185.71c1.949.165,3.9.33,5.848.485v.33c-.132,90.991.187,181.983-.176,272.963-1.861-.121-3.711-.242-5.573-.374C238.135,367.979,238.3,276.844,238.08,185.71Z" transform="translate(-238.08 -185.71)" fill="#f8ba55"/>
+        <path id="Path_22" data-name="Path 22" d="M238.168,468.734c-.2-6.1-.022-12.214.374-18.3,1.641.319,3.282.65,4.934.969.771,7.753.43,15.551.363,23.326l-4.284-.661A12.568,12.568,0,0,1,238.168,468.734Z" transform="translate(-238.079 -158.888)" fill="#f8ba55"/>
+      </g>
+    </g>
+  </g>
+</svg>

docs/schema/v2.1/ComicInfo.xsd

@@ -46,6 +46,13 @@
             <xs:element minOccurs="0" maxOccurs="1" name="CommunityRating" type="Rating"/>
             <xs:element minOccurs="0" maxOccurs="1" default="" name="MainCharacterOrTeam" type="xs:string"/>
             <xs:element minOccurs="0" maxOccurs="1" default="" name="Review" type="xs:string"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="Added" type="xs:string"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="Released" type="xs:string"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="FileSize" type="xs:int"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="FileModifiedTime" type="xs:string"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="FileCreationTime" type="xs:string"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="BookPrice" type="xs:string"/>
+            <xs:element minOccurs="0" maxOccurs="1" default="" name="CustomValuesStore" type="xs:string"/>
         </xs:sequence>
     </xs:complexType>
     <xs:simpleType name="YesNo">

pycbzhelper/__init__.py

@@ -1,5 +0,0 @@
-from .helper import *
-from .comicinfo import *
-from .utils import slugify
-
-__version__ = "3.1.1"

pycbzhelper/comicinfo.py

@@ -1,37 +0,0 @@
-KEYS_STRING = [
-    "Title", "Series", "Number", "AlternateSeries", "AlternateNumber",
-    "Summary", "Notes", "Writer", "Penciller", "Inker", "Colorist",
-    "Letterer", "CoverArtist", "Editor", "Publisher", "Imprint", "Genre",
-    "Web", "Characters", "Teams", "Locations", "ScanInformation",
-    "StoryArc", "SeriesGroup", "CommunityRating"
-]
-
-KEYS_INT = [
-    "Count", "Volume", "AlternateCount", "Year", "Month", "Day", "PageCount"
-]
-
-KEYS_SPECIAL = [
-    "BlackAndWhite", "Manga", "AgeRating", "Pages", "LanguageISO", "Format", "ESN"
-]
-
-KEYS_AGE = [
-    "Adults Only 18+", "Early Childhood", "Everyone", "Everyone 10+",
-    "G", "Kids to Adults", "M", "MA 15+", "Mature 17+", "PG", "R18+",
-    "Rating Pending", "Teen", "X18+", "Rating Pending"
-]
-
-KEYS_FORMAT = [
-    "1 Shot", "1/2", "1-Shot", "Annotation", "Annotations",
-    "Annual", "Anthology", "B&W", "B/W", "B&&W", "Black & White", "Box Set",
-    "Box-Set", "Crossover", "Director's Cut", "Epilogue", "Event", "FCBD",
-    "Flyer", "Giant", "Giant Size", "Giant-Size", "Graphic Novel", "Hardcover",
-    "Hard-Cover", "King", "King Size", "King-Size", "Limited Series", "Magazine",
-    "NSFW", "One Shot", "One-Shot", "Point 1", "Preview", "Prologue", "Reference",
-    "Review", "Reviewed", "Scanlation", "Script", "Series", "Sketch", "Special",
-    "TPB", "Trade Paper Back", "WebComic", "Web Comic", "Year 1", "Year One"
-]
-
-KEYS_PAGE_TYPE = [
-    "FrontCover", "InnerCover", "Roundup", "Story", "Advertisment",
-    "Editorial", "Letters", "Preview", "BackCover", "Other", "Deleted"
-]

pycbzhelper/exceptions.py

@@ -1,18 +0,0 @@
-class PyCBZHelperException(Exception):
-    """Exceptions used by PyCBZHelper."""
-
-
-class InvalidKeyValue(PyCBZHelperException):
-    """The key value is invalid."""
-
-
-class MissingPageFile(PyCBZHelperException):
-    """No page available."""
-
-
-class InvalidFileExtension(PyCBZHelperException):
-    """Invalid file extension."""
-
-
-class FileNotFound(PyCBZHelperException):
-    """The specified source file was not found."""

pycbzhelper/helper.py

@@ -1,151 +0,0 @@
-import shutil
-import zipfile
-
-import requests
-from json2xml import json2xml
-from langcodes import Language
-from PIL import Image
-from pathlib import Path
-
-from pycbzhelper.comicinfo import KEYS_STRING, KEYS_INT, KEYS_SPECIAL, KEYS_AGE, KEYS_FORMAT, KEYS_PAGE_TYPE
-from pycbzhelper.exceptions import InvalidKeyValue, MissingPageFile, FileNotFound, InvalidFileExtension
-from pycbzhelper.utils import get_key_value, delete_none
-
-TMP = Path.home().resolve() / ".cbzhelper"
-
-
-class Helper:
-
-    def __init__(self, kwargs):
-        self._pages = []
-        self.comic_info = self._comic_info(kwargs)
-
-    def _comic_info(self, kwargs) -> str:
-        for key in KEYS_STRING:
-            value = kwargs.get(key)
-            if value is not None and not isinstance(value, str):
-                raise InvalidKeyValue(f"Key must be string: {key}")
-
-        for key in KEYS_INT:
-            value = kwargs.get(key)
-            if value is not None and not isinstance(value, int):
-                raise InvalidKeyValue(f"Key must be integer: {key}")
-
-        for key in KEYS_SPECIAL:
-            value = kwargs.get(key)
-            if value is not None:
-                if key == "BlackAndWhite" and get_key_value(value) not in ["Yes", "No"]:
-                    raise InvalidKeyValue(f"Key must be boolean: {key}")
-                elif key == "Manga" and get_key_value(value) not in ["YesAndRightToLeft", "Yes", "No"]:
-                    raise InvalidKeyValue(f"Key must be boolean or special boolean: {key}")
-                elif key == "AgeRating" and value not in KEYS_AGE:
-                    raise InvalidKeyValue(f"Key must be special age: {key}")
-                elif key == "LanguageISO" and not Language.get(value).is_valid():
-                    raise InvalidKeyValue(f"Key must be ISO language: {key}")
-                elif key == "Format" and value not in KEYS_FORMAT:
-                    raise InvalidKeyValue(f"Key must be special format: {key}")
-                elif key == "Pages":
-                    if isinstance(value, list):
-                        for file in value:
-                            page_file = file.get("File")
-                            if isinstance(page_file, Path):
-                                if not page_file.is_file():
-                                    raise FileNotFound("File does not exist.")
-                            elif isinstance(page_file, str):
-                                if not page_file.startswith("http"):
-                                    raise InvalidKeyValue(f"Key must be an existing file path: {key}")
-                            else:
-                                raise InvalidKeyValue(f"Key must be an existing file path: {key}")
-
-                            page_type = file.get("Type")
-                            if page_type and page_type not in KEYS_PAGE_TYPE:
-                                raise InvalidKeyValue("Key must be special type: Type")
-                            page_double = file.get("DoublePage")
-                            if page_double and get_key_value(page_double) not in ["Yes", "No"]:
-                                raise InvalidKeyValue("Key must be boolean: DoublePage")
-                    else:
-                        raise InvalidKeyValue(f"Key must be a list: {key}")
-
-        xml_pages = []
-        pages = kwargs.get("Pages") or []
-        if len(pages) > 0:
-            # [{"File": "FILE_PATH", "Type": "FrontCover", "DoublePage": False, "Bookmark": "", "Key": ""}]
-            kwargs["PageCount"] = len(pages)
-            xml_pages.append("	<Pages>")
-
-            for i, file in enumerate(pages):
-                page_file = file["File"]
-                if isinstance(page_file, str):
-                    r = requests.get(page_file)
-                    r.raise_for_status()
-                    content = r.content
-                else:
-                    content = page_file.read_bytes()
-
-                page_file = TMP / f"page-{i:03d}.jpg"
-                page_file.parent.mkdir(parents=True, exist_ok=True)
-                page_file.write_bytes(content)
-                self._pages.append(page_file)
-
-                properties = Image.open(page_file)
-                page_type = file.get("Type") or "FrontCover" if i == 0 else "Story"
-
-                items = ["		<Page"]
-                page_double = get_key_value(file.get("DoublePage", False))
-                if page_double == "Yes":
-                    items.append('DoublePage="True"')
-
-                page_bookmark = file.get("Bookmark")
-                if page_bookmark:
-                    items.append(f'Bookmark="{page_bookmark}"')
-
-                page_key = file.get("Key")
-                if page_key:
-                    items.append(f'Key="{page_key}"')
-
-                xml_pages.append(
-                    " ".join(
-                        items) + ' Image="{image}" ImageHeight="{height}" ImageSize="{size}" ImageWidth="{width}" Type="{type}"/>'.format(
-                        double=str(page_double == "Yes"),
-                        image=i,
-                        height=properties.height,
-                        size=len(properties.fp.read()),
-                        width=properties.width,
-                        type=page_type
-                    ))
-            xml_pages.append("	</Pages>")
-        xml_pages.append("</ComicInfo>")
-        kwargs.pop("Pages", None)
-
-        dict_data = {}
-        for key in KEYS_STRING + KEYS_INT + KEYS_SPECIAL:
-            dict_data[key] = get_key_value(kwargs.get(key))
-
-        xml_data = json2xml.Json2xml(delete_none(dict_data), wrapper="ComicInfo", pretty=True, attr_type=False, item_wrap=False).to_xml()
-
-        if not xml_data:
-            xml_data = "\n".join(['<?xml version="1.0" ?>', "<ComicInfo>", "</ComicInfo>"])
-            print("WARNING: No metadata to create.")
-        xml_data = xml_data.replace('<?xml version="1.0" ?>', '<?xml version="1.0" encoding="utf-8"?>')
-        xml_data = xml_data.replace("</ComicInfo>", "\n".join(xml_pages))
-        return xml_data.strip()
-
-    def create_cbz(self, path: Path) -> None:
-        if not len(self._pages) > 0:
-            raise MissingPageFile("No pages available.")
-        if path.suffix != ".cbz":
-            raise InvalidFileExtension("Invalid file extension.")
-
-        path.parent.mkdir(parents=True, exist_ok=True)
-        cbz = zipfile.ZipFile(path, "w", compression=zipfile.ZIP_STORED)
-        clear_path = []
-
-        for i, page in enumerate(self._pages):
-            clear_path.append(page)
-            cbz.writestr(f"page-{i + 1:03d}{page.suffix}", data=page.read_bytes())
-
-        cbz.writestr("ComicInfo.xml", data=self.comic_info.encode("utf-8"))
-        cbz.close()
-
-        self._pages = []
-        shutil.rmtree(TMP)

pycbzhelper/utils.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-from typing import Union
-
-import unicodedata
-
-
-def get_key_value(value: Union[str, bool]) -> str:
-    if isinstance(value, bool):
-        return "Yes" if value else "No"
-    return value
-
-
-def delete_none(_dict: dict) -> dict:
-    """Delete None values recursively from all of the dictionaries, tuples, lists, sets"""
-    if isinstance(_dict, dict):
-        for key, value in list(_dict.items()):
-            if isinstance(value, (list, dict, tuple, set)):
-                _dict[key] = delete_none(value)
-            elif value is None or key is None:
-                del _dict[key]
-            if value == {}:
-                del _dict[key]
-
-    elif isinstance(_dict, (list, set, tuple)):
-        _dict = type(_dict)(delete_none(item) for item in _dict if item is not None)
-    return _dict
-
-
-def slugify(value: Union[str, int], allow_unicode: bool = False) -> str:
-    """
-    Taken from https://github.com/django/django/blob/master/django/utils/text.py
-    Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
-    dashes to single dashes. Remove characters that aren't alphanumerics,
-    underscores, or hyphens. Convert to lowercase. Also strip leading and
-    trailing whitespace, dashes, and underscores.
-    """
-    value = str(value)
-    if allow_unicode:
-        value = unicodedata.normalize("NFKC", value)
-    else:
-        value = unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode("ascii")
-    # value = re.sub(r'[^\w\s-]', '', value.lower())
-    # return re.sub(r'[-\s]+', '-', value).strip('-_')
-    return value

pyproject.toml

@@ -0,0 +1,58 @@
+[project]
+name = "cbz"
+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 = [{name="hyugogirubato", email="65763543+hyugogirubato@users.noreply.github.com"}]
+readme = "README.md"
+keywords = [
+    "python",
+    "cbz",
+    "cbr",
+    "pdf",
+    "ebooks",
+    "manga",
+    "comics",
+    "webtoons",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Topic :: Utilities",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+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"
+
+
+[project.optional-dependencies]
+pillow = ["pillow-avif-plugin>=1.5.2", "pillow-jxl-plugin>=1.3.4"]
+
+[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 }

setup.py

@@ -1,41 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="pycbzhelper",
-    version="3.1.1",
-    author="hyugogirubato",
-    author_email="hyugogirubato@gmail.com",
-    description="Python library for creating CBZ files with metadata.",
-    long_description=open("README.md").read(),
-    long_description_content_type="text/markdown",
-    url="https://github.com/hyugogirubato/pycbzhelper",
-    packages=find_packages(),
-    license="GPL-3.0-only",
-    keywords=[
-        "metadata",
-        "manga",
-        "comics",
-        "ebooks",
-        "cbz"
-    ],
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Intended Audience :: Developers",
-        "Intended Audience :: End Users/Desktop",
-        "Natural Language :: English",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Topic :: Utilities"
-    ],
-    install_requires=[
-        "requests",
-        "json2xml",
-        "langcodes",
-        "Pillow"
-    ],
-    python_requires=">=3.7"
-)

test.py

@@ -1,42 +0,0 @@
-from pathlib import Path
-
-import pycbzhelper
-
-PARENT = Path(__file__).resolve().parent
-
-if __name__ == "__main__":
-    pages = []
-    for i in range(11):
-        pages.append({"File": (PARENT / "docs" / "images" / f"page-{i:03d}.jpg")})
-
-    metadata = {
-        "Title": "T1 - Arrête de me chauffer, Nagatoro",
-        "Series": "Arrête de me chauffer, Nagatoro",
-        "Number": "1",
-        "Count": 8,
-        "Volume": 1,
-        "Summary": "Nagatoro est en seconde. Pleine d\u2019assurance, joueuse, moqueuse, elle se d\u00e9couvre un jour un passe-temps favori : martyriser son \u201cSenpai\u201d, lyc\u00e9en de premi\u00e8re timide et mal dans sa peau. Nagatoro taquine, agace, aguiche, va parfois trop loin... mais qu\u2019a-t-elle vraiment derri\u00e8re la t\u00eate ? Et si derri\u00e8re ses moqueries elle cachait une v\u00e9ritable affection ?  Et si finalement, ses farces permettaient \u00e0 Senpai de s\u2019affirmer ?",
-        "Year": 2021,
-        "Month": 3,
-        "Day": 12,
-        "Writer": "Nanashi",
-        "Inker": "Nanashi",
-        "Editor": "Noeve Grafx",
-        "Publisher": "Noeve Grafx",
-        "Imprint": "Noeve Grafx",
-        "Genre": "Shonen",
-        "Web": "http://www.izneo.com/en/manga/shonen/arrete-de-me-chauffer-nagatoro-37560/arrete-de-me-chauffer-nagatoro-86232",
-        "LanguageISO": "fr",
-        "Format": "Preview",
-        "BlackAndWhite": True,
-        "Manga": "YesAndRightToLeft",
-        "AgeRating": "Everyone 10+",
-        "CommunityRating": "5.0",
-        "ean": "9782490676569",
-        "Pages": pages
-    }
-
-    path = PARENT / "eBooks" / "Arrête de me chauffer, Nagatoro.cbz"
-    helper = pycbzhelper.Helper(metadata)
-    helper.create_cbz(path=path)
-    print(f"I: File created: {path}")

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

@@ -0,0 +1,59 @@
+from pathlib import Path
+
+from cbz.comic import ComicInfo
+from cbz.constants import PageType, YesNo, Manga, AgeRating, Format
+from cbz.page import PageInfo
+
+PARENT = Path(__file__).parent
+
+if __name__ == '__main__':
+    paths = list((PARENT / 'fixtures' / 'images').iterdir())
+
+    # Load each page from the 'images' folder into a list of PageInfo objects
+    pages = [
+        PageInfo.load(
+            path=path,
+            type=PageType.FRONT_COVER if i == 0 else PageType.BACK_COVER if i == len(paths) - 1 else PageType.STORY
+        )
+        for i, path in enumerate(paths)
+    ]
+
+    # Create a ComicInfo object using ComicInfo.from_pages() method
+    comic = ComicInfo.from_pages(
+        pages=pages,
+        title='T1 - Arrête de me chauffer, Nagatoro',
+        series='Arrête de me chauffer, Nagatoro',
+        number=1,
+        count=8,
+        volume=1,
+        summary='Nagatoro est en seconde. Pleine d\u2019assurance, joueuse, moqueuse, elle se d\u00e9couvre un jour un passe-temps favori : martyriser son \u201cSenpai\u201d, lyc\u00e9en de premi\u00e8re timide et mal dans sa peau. Nagatoro taquine, agace, aguiche, va parfois trop loin... mais qu\u2019a-t-elle vraiment derri\u00e8re la t\u00eate ? Et si derri\u00e8re ses moqueries elle cachait une v\u00e9ritable affection ?  Et si finalement, ses farces permettaient \u00e0 Senpai de s\u2019affirmer ?',
+        year=2021,
+        month=3,
+        day=12,
+        writer='Nanashi',
+        inker='Nanashi',
+        editor='Noeve Grafx',
+        publisher='Noeve Grafx',
+        imprint='Noeve Grafx',
+        genre='Shonen',
+        web='http://www.izneo.com/en/manga/shonen/arrete-de-me-chauffer-nagatoro-37560/arrete-de-me-chauffer-nagatoro-86232',
+        language_iso='fr',
+        format=Format.PREVIEW,
+        black_white=YesNo.YES,
+        manga=Manga.RIGHT_LEFT,
+        age_rating=AgeRating.EVERYONE10,
+        community_rating=5,
+        ean='9782490676569'
+    )
+
+    # Show the comic using the show()
+    comic.show()
+
+    # Pack the comic book content into a CBZ file format
+    cbz_content = comic.pack(rename=True)
+
+    # Define the path where the CBZ file will be saved
+    cbz_path = PARENT / f'{comic.title}.cbz'
+
+    # Write the CBZ content to the specified path
+    cbz_path.write_bytes(cbz_content)

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')