Updated the Codebase to use pathlib instead of using os.path and path.py

hatch_build.py

@@ -20,18 +20,13 @@ def initialize(self, version, build_data):
             logger.info("JS dependencies are already installed, skipping it")
             return
         subprocess.run(
-            str(Path(self.root).joinpath("get_js_deps.sh")),
+            str(Path(self.root) / "get_js_deps.sh"),
             check=True,
         )
         return super().initialize(version, build_data)
 
     def deps_already_installed(self) -> bool:
         for dep in JS_DEPS:
-            if (
-                not Path(self.root)
-                .joinpath("gutebergtozim/templates")
-                .joinpath(dep)
-                .exists()
-            ):
+            if not Path(self.root, "gutebergtozim/templates", dep).exists():
                 return False
         return True

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "gutenberg2zim"
 authors = [{ name = "Kiwix", email = "dev@kiwix.org" }]
 keywords = ["kiwix", "zim", "offline", "gutenberg"]
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.12"
 description = "Make ZIM file from Gutenberg books"
 readme = "pypi-readme.rst"
 license = { text = "GPL-3.0-or-later" }

src/gutenberg2zim/download.py

@@ -1,15 +1,14 @@
 import os
-import pathlib
 import shutil
 import tempfile
 import zipfile
 from multiprocessing.dummy import Pool
+from pathlib import Path
 from pprint import pprint as pp
 
 import apsw
 import backoff
 from kiwixstorage import KiwixStorage
-from path import Path
 
 from gutenberg2zim.constants import TMP_FOLDER, logger
 from gutenberg2zim.database import Book, BookFormat
@@ -36,15 +35,15 @@
 #         return False
 
 
-def handle_zipped_epub(zippath, book, dst_dir: pathlib.Path):
+def handle_zipped_epub(zippath, book, dst_dir: Path):
     def clfn(fn):
-        return os.path.join(*os.path.split(fn)[1:])
+        return Path(*Path(fn).parts[1:])
 
     def is_safe(fname):
         fname = ensure_unicode(clfn(fname))
-        if Path(fname).basename() == fname:
+        if Path(fname).name == fname:
             return True
-        return fname == os.path.join("images", Path(fname).splitpath()[-1])
+        return fname == Path("images") / Path(fname).name
 
     zipped_files = []
     # create temp directory to extract to
@@ -53,7 +52,7 @@
         with zipfile.ZipFile(zippath, "r") as zf:
             # check that there is no insecure data (absolute names)
             if sum([1 for n in zf.namelist() if not is_safe(ensure_unicode(n))]):
-                Path(tmpd).rmtree_p()
+                shutil.rmtree(tmpd)
                 return False
             # zipped_files = [clfn(fn) for fn in zf.namelist()]
             zipped_files = zf.namelist()
@@ -73,25 +72,25 @@
     # move all extracted files to proper locations
     for zipped_file in zipped_files:
         # skip folders
-        if not Path(zipped_file).ext:
+        if not Path(zipped_file).is_file:
             continue
 
-        src = os.path.join(tmpd, zipped_file)
-        if os.path.exists(src):
-            fname = Path(zipped_file).basename()
+        src = Path(tmpd) / zipped_file
+        if src.exists():
+            fname = Path(zipped_file).name
 
             if fname.endswith(".html") or fname.endswith(".htm"):
                 if mhtml:
                     if fname.startswith(f"{book.id}-h."):
-                        dst = dst_dir.joinpath(f"{book.id}.html")
+                        dst = dst_dir / f"{book.id}.html"
                     else:
-                        dst = dst_dir.joinpath(f"{book.id}_{fname}")
+                        dst = dst_dir / f"{book.id}_{fname}"
                 else:
-                    dst = dst_dir.joinpath(f"{book.id}.html")
+                    dst = dst_dir / f"{book.id}.html"
             else:
-                dst = dst_dir.joinpath(f"{book.id}_{fname}")
+                dst = dst_dir / f"{book.id}_{fname}"
             try:
-                Path(src).move(str(dst))
+                src.rename(dst)
             except Exception as e:
                 import traceback
 
@@ -102,12 +101,12 @@
     # delete temp directory and zipfile
     if Path(zippath).exists():
         os.unlink(zippath)
-    Path(tmpd).rmtree_p()
+    shutil.rmtree(tmpd)
 
 
 def download_book(
     book: Book,
-    download_cache: str,
+    download_cache: Path,
     formats: list[str],
     *,
     force: bool,
@@ -124,13 +123,14 @@
     if "html" not in formats:
         formats.append("html")
 
-    book_dir = pathlib.Path(download_cache).joinpath(str(book.id))
-    optimized_dir = book_dir.joinpath("optimized")
-    unoptimized_dir = book_dir.joinpath("unoptimized")
+    book_dir = download_cache / str(book.id)
+    optimized_dir = book_dir / "optimized"
+    unoptimized_dir = book_dir / "unoptimized"
     unsuccessful_formats = []
+
     for book_format in formats:
-        unoptimized_fpath = unoptimized_dir.joinpath(fname_for(book, book_format))
-        optimized_fpath = optimized_dir.joinpath(archive_name_for(book, book_format))
+        unoptimized_fpath = unoptimized_dir / fname_for(book, book_format)
+        optimized_fpath = optimized_dir / archive_name_for(book, book_format)
 
         # check if already downloaded
         if (unoptimized_fpath.exists() or optimized_fpath.exists()) and not force:
@@ -233,7 +233,7 @@
 
             # HTML files are *sometime* available as ZIP files
             if url.endswith(".zip"):
-                zpath = unoptimized_dir.joinpath(f"{fname_for(book, book_format)}.zip")
+                zpath = unoptimized_dir / f"{fname_for(book, book_format)}.zip"
 
                 etag = get_etag_from_url(url)
                 if s3_storage:
@@ -329,10 +329,9 @@
         etag = get_etag_from_url(url)
         downloaded_from_cache = False
         cover = f"{book.id}_cover_image.jpg"
-        if (
-            book_dir.joinpath("optimized").joinpath(cover).exists()
-            or book_dir.joinpath("unoptimized").joinpath(cover).exists()
-        ):
+        if (book_dir / "optimized" / cover).exists() or (
+            book_dir / "unoptimized" / cover
+        ).exists():
             logger.debug(f"Cover already exists for book #{book.id}")
             return
         if s3_storage:
@@ -343,21 +342,21 @@
                 book=book,
                 etag=etag,
                 book_format="cover",
-                dest_dir=book_dir.joinpath("optimized"),
+                dest_dir=book_dir / "optimized",
                 s3_storage=s3_storage,
                 optimizer_version=optimizer_version,
             )
         if not downloaded_from_cache:
             logger.debug(f"Downloading {url}")
-            if download_file(url, book_dir.joinpath("unoptimized").joinpath(cover)):
+            if download_file(url, book_dir / "unoptimized" / cover):
                 book.cover_etag = etag
                 book.save()
     else:
         logger.debug(f"No Book Cover found for Book #{book.id}")
 
 
 def download_all_books(
-    download_cache: str,
+    download_cache: Path,
     concurrency: int,
     languages: list[str],
     formats: list[str],
@@ -372,7 +371,7 @@
     )
 
     # ensure dir exist
-    Path(download_cache).mkdir_p()
+    download_cache.mkdir(parents=True, exist_ok=True)
 
     def backoff_busy_error_hdlr(details):
         logger.warning(

src/gutenberg2zim/entrypoint.py

@@ -1,8 +1,7 @@
-import os
 import sys
+from pathlib import Path
 
 from docopt import docopt
-from path import Path
 
 from gutenberg2zim.checkdeps import check_dependencies
 from gutenberg2zim.constants import TMP_FOLDER_PATH, VERSION, logger
@@ -90,7 +89,7 @@
         arguments.get("--rdf-url")
         or "http://www.gutenberg.org/cache/epub/feeds/rdf-files.tar.bz2"
     )
-    dl_cache = arguments.get("--dl-folder") or os.path.join("dl-cache")
+    dl_cache = Path(arguments.get("--dl-folder") or "dl-cache")
     books_csv = arguments.get("--books") or ""
     zim_title = arguments.get("--zim-title")
     zim_desc = arguments.get("--zim-desc")
@@ -209,7 +208,7 @@
         if do_zim:
             logger.info("BUILDING ZIM dynamically")
             build_zimfile(
-                output_folder=Path(one_lang_one_zim_folder or ".").abspath(),
+                output_folder=Path(one_lang_one_zim_folder or ".").resolve(),
                 download_cache=dl_cache,
                 concurrency=concurrency,
                 languages=zim_lang,