shortbox 0.4.0__py3-none-any.whl

shortbox/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["Comic"]
+__version__ = "0.4.0"
+
+from shortbox.comic import Comic

shortbox/archives/__init__.py

@@ -0,0 +1,27 @@
+__all__ = ["Archive", "TarArchive", "ZipArchive"]
+
+from importlib.util import find_spec
+
+from shortbox.archives.base import Archive
+from shortbox.archives.tar import TarArchive
+from shortbox.archives.zip import ZipArchive
+from shortbox.registries import archive_registry
+
+archive_registry.register(TarArchive, ".tar")
+archive_registry.register(ZipArchive, ".zip")
+
+if find_spec("pdffile") is not None:
+    from shortbox.archives.pdf import PdfArchive
+
+    archive_registry.register(PdfArchive)
+    __all__ += ("PdfArchive",)
+if find_spec("rarfile") is not None:
+    from shortbox.archives.rar import RarArchive
+
+    archive_registry.register(RarArchive, ".rar")
+    __all__ += ("RarArchive",)
+if find_spec("py7zr") is not None:
+    from shortbox.archives.sevenzip import SevenZipArchive
+
+    archive_registry.register(SevenZipArchive, ".7z")
+    __all__ += ("SevenZipArchive",)

shortbox/archives/base.py

@@ -0,0 +1,39 @@
+__all__ = ["Archive"]
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import ClassVar
+
+
+class Archive(ABC):
+    extension: ClassVar[str]
+    can_create: ClassVar[bool]
+
+    def __init__(self, file: Path):
+        self.file = file
+
+    @classmethod
+    @abstractmethod
+    def probe(cls, file: Path) -> bool: ...
+
+    @abstractmethod
+    def extract(self, filenames: list[str], destination: Path) -> None: ...
+
+    @abstractmethod
+    def list_filenames(self) -> list[str]: ...
+
+    @abstractmethod
+    def read_file(self, filename: str) -> bytes: ...
+
+    @abstractmethod
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None: ...
+
+    @abstractmethod
+    def remove_file(self, filename: str) -> None: ...
+
+    @abstractmethod
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None: ...
+
+    @classmethod
+    @abstractmethod
+    def archive_files(cls, parent: Path, name: str, files: list[Path]) -> Path: ...

shortbox/archives/pdf.py

@@ -0,0 +1,82 @@
+__all__ = ["PdfArchive"]
+
+from pathlib import Path
+from typing import ClassVar
+
+from natsort import humansorted, ns
+from pdffile import PDFFile
+
+from shortbox.archives.base import Archive
+from shortbox.errors import ArchiveCapabilityError, ArchiveError
+
+
+class PdfArchive(Archive):
+    extension: ClassVar[str] = ".pdf"
+    can_create: ClassVar[bool] = False
+
+    @classmethod
+    def probe(cls, file: Path) -> bool:
+        return PDFFile.is_pdffile(str(file))
+
+    def extract(self, filenames: list[str], destination: Path) -> None:
+        try:
+            with PDFFile(path=self.file) as archive:
+                for filename in filenames:
+                    try:
+                        int(filename)
+                        props: dict = {}
+                        data = archive.read(filename, fmt="pixmap_jpeg", props=props)
+                        target = destination / f"{filename}.{props['ext']}"
+                    except ValueError:
+                        data = archive.read(filename)
+                        target = destination / filename
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    target.write_bytes(data)
+        except Exception as err:
+            raise ArchiveError(
+                f"Unable to extract files from {self.file.name} to {destination}."
+            ) from err
+
+    def list_filenames(self) -> list[str]:
+        try:
+            with PDFFile(path=self.file) as archive:
+                return humansorted(archive.namelist(), alg=ns.G | ns.P)
+        except Exception as err:
+            raise ArchiveError(f"Unable to list files from {self.file.name}.") from err
+
+    def read_file(self, filename: str) -> bytes:
+        try:
+            with PDFFile(path=self.file) as archive:
+                try:
+                    int(filename)
+                    return archive.read(filename, fmt="pixmap_jpeg")
+                except ValueError:
+                    return archive.read(filename)
+        except Exception as err:
+            raise ArchiveError(f"Unable to read {filename}.") from err
+
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None:
+        filenames = self.list_filenames()
+        if filename in filenames and not override:
+            raise ArchiveError(f"Unable to write {filename} as it already exists.")
+        if filename in filenames and override:
+            self.remove_file(filename=filename)
+        try:
+            with PDFFile(path=self.file) as archive:
+                archive.writestr(filename, data)
+        except Exception as err:
+            raise ArchiveError(f"Unable to write {filename}.") from err
+
+    def remove_file(self, filename: str) -> None:
+        try:
+            with PDFFile(path=self.file) as archive:
+                archive.remove(filename)
+        except Exception as err:
+            raise ArchiveError(f"Unable to remove {filename}.") from err
+
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("PDFArchive does not support renaming files")
+
+    @classmethod
+    def archive_files(cls, parent: Path, name: str, files: list[Path]) -> Path:  # noqa: ARG003
+        raise ArchiveCapabilityError("PDFArchive does not support archiving files")

shortbox/archives/rar.py

@@ -0,0 +1,55 @@
+__all__ = ["RarArchive"]
+
+from pathlib import Path
+from typing import ClassVar
+
+from natsort import humansorted, ns
+from rarfile import RarFile, is_rarfile
+
+from shortbox.archives.base import Archive
+from shortbox.errors import ArchiveCapabilityError, ArchiveError
+
+
+class RarArchive(Archive):
+    extension: ClassVar[str] = ".cbr"
+    can_create: ClassVar[bool] = False
+
+    @classmethod
+    def probe(cls, file: Path) -> bool:
+        return is_rarfile(file)
+
+    def extract(self, filenames: list[str], destination: Path) -> None:
+        try:
+            with RarFile(file=self.file, mode="r") as archive:
+                archive.extractall(path=destination, members=filenames)
+        except Exception as err:
+            raise ArchiveError(
+                f"Unable to extract files from {self.file.name} to {destination}."
+            ) from err
+
+    def list_filenames(self) -> list[str]:
+        try:
+            with RarFile(file=self.file, mode="r") as archive:
+                return humansorted(archive.namelist(), alg=ns.G | ns.P)
+        except Exception as err:
+            raise ArchiveError(f"Unable to list files from {self.file.name}.") from err
+
+    def read_file(self, filename: str) -> bytes:
+        try:
+            with RarFile(file=self.file, mode="r") as archive:
+                return archive.read(filename)
+        except Exception as err:
+            raise ArchiveError(f"Unable to read {filename}.") from err
+
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("RarArchive does not support writing files")
+
+    def remove_file(self, filename: str) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("RarArchive does not support removing files")
+
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("RarArchive does not support renaming files")
+
+    @classmethod
+    def archive_files(cls, parent: Path, name: str, files: list[Path]) -> Path:  # noqa: ARG003
+        raise ArchiveCapabilityError("RarArchive does not support archiving files")

shortbox/archives/sevenzip.py

@@ -0,0 +1,70 @@
+__all__ = ["SevenZipArchive"]
+
+from pathlib import Path
+from sys import maxsize
+from typing import ClassVar
+
+from natsort import humansorted, ns
+from py7zr import SevenZipFile, is_7zfile
+from py7zr.io import BytesIOFactory
+
+from shortbox.archives.base import Archive
+from shortbox.errors import ArchiveCapabilityError, ArchiveError
+
+
+class SevenZipArchive(Archive):
+    extension: ClassVar[str] = ".cb7"
+    can_create: ClassVar[bool] = True
+
+    @classmethod
+    def probe(cls, file: Path) -> bool:
+        return is_7zfile(file)
+
+    def extract(self, filenames: list[str], destination: Path) -> None:
+        try:
+            with SevenZipFile(file=self.file, mode="r") as archive:
+                archive.extract(path=destination, targets=filenames)
+        except Exception as err:
+            raise ArchiveError(
+                f"Unable to extract files from {self.file.name} to {destination}."
+            ) from err
+
+    def list_filenames(self) -> list[str]:
+        try:
+            with SevenZipFile(file=self.file, mode="r") as archive:
+                return humansorted(archive.getnames(), alg=ns.G | ns.P)
+        except Exception as err:
+            raise ArchiveError(f"Unable to list files from {self.file.name}.") from err
+
+    def read_file(self, filename: str) -> bytes:
+        try:
+            with SevenZipFile(file=self.file, mode="r") as archive:
+                factory = BytesIOFactory(maxsize)
+                archive.extract(targets=[filename], factory=factory)
+                if file_obj := factory.products.get(filename):
+                    return file_obj.read()
+                raise ArchiveError(f"Unable to read {filename} in {self.file.name}")  # noqa: TRY301
+        except ArchiveError:
+            raise
+        except Exception as err:
+            raise ArchiveError(f"Unable to read {filename} in {self.file.name}.") from err
+
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("7zArchive does not support writing files")
+
+    def remove_file(self, filename: str) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("7zArchive does not support removing files")
+
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("7zArchive does not support renaming files")
+
+    @classmethod
+    def archive_files(cls, parent: Path, name: str, files: list[Path]) -> Path:
+        output_file = parent / (name + cls.extension)
+        try:
+            with SevenZipFile(output_file, "w") as archive:
+                for file in files:
+                    archive.write(file, arcname=file.name)
+            return output_file
+        except Exception as err:
+            raise ArchiveError(f"Unable to archive files to {output_file.name}") from err

shortbox/archives/tar.py

@@ -0,0 +1,60 @@
+__all__ = ["TarArchive"]
+
+import tarfile
+from pathlib import Path
+from tarfile import is_tarfile
+from typing import ClassVar
+
+from natsort import humansorted, ns
+
+from shortbox.archives.base import Archive
+from shortbox.errors import ArchiveCapabilityError, ArchiveError
+
+
+class TarArchive(Archive):
+    extension: ClassVar[str] = ".cbt"
+    can_create: ClassVar[bool] = True
+
+    @classmethod
+    def probe(cls, file: Path) -> bool:
+        return is_tarfile(file)
+
+    def extract(self, filenames: list[str], destination: Path) -> None:
+        try:
+            with tarfile.open(name=self.file, mode="r") as archive:
+                members = [archive.getmember(name) for name in filenames]
+                archive.extractall(path=destination, members=members, filter="data")
+        except Exception as err:
+            raise ArchiveError(
+                f"Unable to extract files from {self.file.name} to {destination}."
+            ) from err
+
+    def list_filenames(self) -> list[str]:
+        try:
+            with tarfile.open(name=self.file, mode="r") as archive:
+                return humansorted(archive.getnames(), alg=ns.G | ns.P)
+        except Exception as err:
+            raise ArchiveError(f"Unable to list files from {self.file.name}.") from err
+
+    def read_file(self, filename: str) -> bytes:  # noqa: ARG002
+        raise ArchiveCapabilityError("TarArchive does not support reading files")
+
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("TarArchive does not support writing files")
+
+    def remove_file(self, filename: str) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("TarArchive does not support removing files")
+
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None:  # noqa: ARG002
+        raise ArchiveCapabilityError("TarArchive does not support renaming files")
+
+    @classmethod
+    def archive_files(cls, parent: Path, name: str, files: list[Path]) -> Path:
+        output_file = parent / (name + cls.extension)
+        try:
+            with tarfile.open(name=output_file, mode="w") as archive:
+                for file in files:
+                    archive.add(file, arcname=file.name)
+            return output_file
+        except Exception as err:
+            raise ArchiveError(f"Unable to archive files to {output_file.name}") from err

shortbox/archives/zip.py

@@ -0,0 +1,97 @@
+__all__ = ["ZipArchive"]
+
+from pathlib import Path
+from typing import ClassVar
+
+from natsort import humansorted, ns
+from zipremove import ZIP_DEFLATED, ZipFile, is_zipfile
+
+from shortbox.archives.base import Archive
+from shortbox.errors import ArchiveError, MissingArchiveMemberError
+
+
+class ZipArchive(Archive):
+    extension: ClassVar[str] = ".cbz"
+    can_create: ClassVar[bool] = True
+
+    @classmethod
+    def probe(cls, file: Path) -> bool:
+        return is_zipfile(file)
+
+    def extract(self, filenames: list[str], destination: Path) -> None:
+        print(f"Extracting {self.file.name} archive")  # noqa: T201
+        try:
+            with ZipFile(file=self.file, mode="r") as archive:
+                archive.extractall(path=destination, members=filenames)
+        except Exception as err:
+            raise ArchiveError(
+                f"Unable to extract files from {self.file.name} to {destination}."
+            ) from err
+
+    def list_filenames(self) -> list[str]:
+        try:
+            with ZipFile(file=self.file, mode="r") as archive:
+                return humansorted(archive.namelist(), alg=ns.G | ns.P)
+        except Exception as err:
+            raise ArchiveError(f"Unable to list files from {self.file.name}.") from err
+
+    def read_file(self, filename: str) -> bytes:
+        try:
+            with ZipFile(file=self.file, mode="r") as archive, archive.open(filename) as zip_file:
+                return zip_file.read()
+        except Exception as err:
+            raise ArchiveError(f"Unable to read {filename}.") from err
+
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None:
+        try:
+            with ZipFile(file=self.file, mode="a") as archive:
+                if filename in archive.namelist():
+                    if not override:
+                        raise ArchiveError(f"Unable to write {filename} as it already exists.")  # noqa: TRY301
+                    removed = archive.remove(filename)  # ty: ignore[unresolved-attribute]
+                    archive.repack([removed])  # ty: ignore[unresolved-attribute]
+                archive.writestr(filename, data)
+        except ArchiveError:
+            raise
+        except Exception as err:
+            raise ArchiveError(f"Unable to write {filename}.") from err
+
+    def remove_file(self, filename: str) -> None:
+        if filename not in self.list_filenames():
+            raise MissingArchiveMemberError(f"Unable to remove {filename} as it does not exist.")
+        try:
+            with ZipFile(file=self.file, mode="a") as archive:
+                removed = archive.remove(filename)  # ty: ignore[unresolved-attribute]
+                archive.repack([removed])  # ty: ignore[unresolved-attribute]
+        except Exception as err:
+            raise ArchiveError(f"Unable to delete {filename}.") from err
+
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None:
+        if filename not in self.list_filenames():
+            raise MissingArchiveMemberError(f"Unable to rename {filename} as it does not exist.")
+        try:
+            removed = []
+            with ZipFile(file=self.file, mode="a") as archive:
+                if new_name in archive.namelist():
+                    if not override:
+                        raise ArchiveError(  # noqa: TRY301
+                            f"Unable to rename {filename} as {new_name} already exists."
+                        )
+                    removed.append(archive.remove(new_name))  # ty: ignore[unresolved-attribute]
+                removed.append(archive.remove(archive.copy(filename, new_name)))  # ty: ignore[unresolved-attribute]
+                archive.repack(removed)  # ty: ignore[unresolved-attribute]
+        except ArchiveError:
+            raise
+        except Exception as err:
+            raise ArchiveError(f"Unable to rename {filename} to {new_name}.") from err
+
+    @classmethod
+    def archive_files(cls, parent: Path, name: str, files: list[Path]) -> Path:
+        output_file = parent / (name + cls.extension)
+        try:
+            with ZipFile(file=output_file, mode="w", compression=ZIP_DEFLATED) as archive:
+                for file in files:
+                    archive.write(file, arcname=file.name)
+            return output_file
+        except Exception as err:
+            raise ArchiveError(f"Unable to archive files to {output_file.name}.") from err

shortbox/comic.py

@@ -0,0 +1,216 @@
+__all__ = ["Comic"]
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import TypeVar
+
+from msgspec_xml import decode, encode
+from natsort import humansorted, ns
+
+from shortbox.archives.base import Archive
+from shortbox.errors import (
+    ArchiveCapabilityError,
+    ArchiveError,
+    MissingArchiveMemberError,
+    UnsupportedMetadataError,
+)
+from shortbox.metadata.base import Metadata
+from shortbox.registries import archive_registry, metadata_registry
+
+MetadataT = TypeVar("MetadataT", bound=Metadata)
+
+
+class Comic:
+    def __init__(self, archive: Archive, tmpdir: Path):
+        self._archive = archive
+        self._tmpdir = tmpdir
+        self._extracted: bool = False
+        self._dirty: bool = False
+        self._metadata_cache: dict[type[Metadata], Metadata] = {}
+
+    @classmethod
+    @contextmanager
+    def open(cls, file: Path) -> Generator["Comic"]:
+        archive = archive_registry.find(file=file)
+        with TemporaryDirectory() as temp:
+            instance = cls(archive=archive, tmpdir=Path(temp))
+            try:
+                yield instance
+                if instance._extracted and instance._dirty:
+                    instance._archive.file = instance._archive.archive_files(
+                        parent=instance.file.parent,
+                        name=instance.file.stem,
+                        files=instance._iter_extracted_files(),
+                    )
+            finally:
+                instance._extracted = False
+                instance._dirty = False
+
+    @property
+    def file(self) -> Path:
+        return self._archive.file
+
+    def _iter_extracted_files(self) -> list[Path]:
+        return humansorted([p for p in self._tmpdir.rglob("*") if p.is_file()], alg=ns.G | ns.P)
+
+    def list_filenames(self) -> list[str]:
+        if self._extracted:
+            return [str(x.relative_to(self._tmpdir)) for x in self._iter_extracted_files()]
+        return self._archive.list_filenames()
+
+    def _ensure_extracted(self) -> None:
+        if not self._extracted:
+            self._archive.extract(
+                filenames=self._archive.list_filenames(), destination=self._tmpdir
+            )
+            self._extracted = True
+
+    def read_file(self, filename: str) -> bytes:
+        try:
+            return self._archive.read_file(filename=filename)
+        except ArchiveCapabilityError:
+            self._ensure_extracted()
+            tmp = self._tmpdir / filename
+            return tmp.read_bytes()
+
+    def write_file(self, filename: str, data: bytes, override: bool = False) -> None:
+        self._invalidate_cache(filename=filename)
+        try:
+            return self._archive.write_file(filename=filename, data=data, override=override)
+        except ArchiveCapabilityError as err:
+            if not self._archive.can_create:
+                raise
+            self._ensure_extracted()
+            tmp = self._tmpdir / filename
+            if tmp.exists() and not override:
+                raise ArchiveError(f"Unable to write {filename} as it already exists.") from err
+            tmp.write_bytes(data)
+            self._dirty = True
+            return None
+
+    def remove_file(self, filename: str) -> None:
+        self._invalidate_cache(filename=filename)
+        try:
+            return self._archive.remove_file(filename=filename)
+        except ArchiveCapabilityError as err:
+            if not self._archive.can_create:
+                raise
+            self._ensure_extracted()
+            tmp = self._tmpdir / filename
+            if not tmp.exists():
+                raise MissingArchiveMemberError(
+                    f"Unable to remove {filename} as it does not exist."
+                ) from err
+            tmp.unlink()
+            self._dirty = True
+            return None
+
+    def rename_file(self, filename: str, new_name: str, override: bool = False) -> None:
+        self._invalidate_cache(filename=filename)
+        try:
+            return self._archive.rename_file(
+                filename=filename, new_name=new_name, override=override
+            )
+        except ArchiveCapabilityError as err:
+            if not self._archive.can_create:
+                raise
+            self._ensure_extracted()
+            tmp = self._tmpdir / filename
+            if not tmp.exists():
+                raise MissingArchiveMemberError(
+                    f"Unable to rename {filename} as it does not exist."
+                ) from err
+            new_tmp = self._tmpdir / new_name
+            if new_tmp.exists() and not override:
+                raise ArchiveError(
+                    f"Unable to rename {filename} as {new_name} already exists."
+                ) from err
+            tmp.rename(new_tmp)
+            self._dirty = True
+            return None
+
+    def _invalidate_cache(self, filename: str) -> None:
+        try:
+            metadata_cls = metadata_registry.find(filename=filename)
+        except UnsupportedMetadataError:
+            return
+        self._metadata_cache.pop(metadata_cls, None)
+
+    def _iter_metadata_files(self) -> Generator[tuple[str, type[Metadata]]]:
+        for filename in self.list_filenames():
+            try:
+                metadata_cls = metadata_registry.find(filename=filename)
+            except UnsupportedMetadataError:
+                continue
+            yield filename, metadata_cls
+
+    def get_metadata(self, metadata_type: type[MetadataT]) -> MetadataT | None:
+        cached = self._metadata_cache.get(metadata_type)
+        if isinstance(cached, metadata_type):
+            return cached
+        for filename, metadata_cls in self._iter_metadata_files():
+            if metadata_cls is not metadata_type:
+                continue
+            instance = decode(self.read_file(filename=filename), type_=metadata_type)
+            self._metadata_cache[metadata_type] = instance
+            return instance
+        return None
+
+    def set_metadata(self, metadata: Metadata) -> None:
+        metadata_type = type(metadata)
+        filename = metadata.filename
+        data = encode(metadata, indent=4, xml_declaration=True)
+        self.write_file(filename=filename, data=data, override=True)
+        self._metadata_cache[metadata_type] = metadata
+
+    def remove_metadata(self, metadata_type: type[Metadata]) -> None:
+        filename = metadata_type.filename
+        self.remove_file(filename=filename)
+
+    @property
+    def metadata(self) -> dict[type[Metadata], Metadata]:
+        for filename, metadata_cls in self._iter_metadata_files():
+            if metadata_cls not in self._metadata_cache:
+                self._metadata_cache[metadata_cls] = decode(
+                    self.read_file(filename=filename), type_=metadata_cls
+                )
+        return dict(self._metadata_cache)
+
+    def convert(
+        self,
+        archive_type: type[Archive],
+        delete_original: bool = False,
+        raise_on_existing: bool = True,
+    ) -> Path:
+        if not archive_type.can_create:
+            raise ArchiveCapabilityError(
+                f"{archive_type.__name__} does not support archiving files"
+            )
+        target_path = self.file.with_suffix(archive_type.extension)
+        if target_path.resolve() == self.file.resolve():
+            if raise_on_existing:
+                raise ArchiveError(f"{target_path!r} already exists")
+            return self.file
+        self._ensure_extracted()
+        files = self._iter_extracted_files()
+        new_path = archive_type.archive_files(
+            parent=target_path.parent, name=target_path.stem, files=files
+        )
+        original_file = self.file
+        self._archive = archive_type(file=new_path)
+        self._extracted = False
+        self._dirty = False
+        self._metadata_cache.clear()
+        if delete_original:
+            original_file.unlink()
+        return new_path
+
+    def get_cover(self) -> bytes:
+        for filename in self.list_filenames():
+            try:
+                metadata_registry.find(filename=filename)
+            except UnsupportedMetadataError:  # noqa: PERF203
+                return self.read_file(filename=filename)
+        raise MissingArchiveMemberError(f"{self.file.name!r} contains no files to use as a cover.")