pixboards 0.2.25__tar.gz

pixboards-0.2.25/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: pixboards
+Version: 0.2.25
+Description-Content-Type: text/markdown
+
+# notice
+
+repo finally changed to [https://github.com/flynnsharwood/pixBoards.git](https://github.com/flynnsharwood/pixBoards.git)
+
+Gui has not been set up yet. Don't try to run the gui.py
+
+title and heading use the board name now. favicon added, can be changed, check the templates folder. 
+
+~~if you are using the PyPi package, you will need to have a running postgres server, else it won't work.~~ It works now. 
+
+# pixBoards
+
+pixBoards is a python library to help you organise your images and videos into masonry-containers (the pinterest layout)
+
+It outputs simple html files with links to the images. Simplicity was the aim here, so don't expect fancy stuff in it.
+
+It organises the images into "boards" which can be nested inside other boards. (Just think of them as a folder for now)
+
+You can also automatically upload the files to imgchest and use those links in the output html files. You can then simply host these output files and you will have a working webpage. (If you had to use local files, you'd have to host the images too, which would be a pain in) (use --upload for that)
+
+you can also use lists of imagelinks to create boards.
+
+I also recently added the ability to use links in sidecarfiles to use as upload links instead of uploading the image to imgchest. (if you used a bulk downloader like gallery-dl, you'd be able to easily create such sidecar files every time you download.)
+
+### screenshots
+
+example of index file
+![https://cdn.imgchest.com/files/4apc5px5gv4.png](https://cdn.imgchest.com/files/4apc5px5gv4.png)
+
+example of image board
+![https://cdn.imgchest.com/files/yrgcnjaxew4.png](https://cdn.imgchest.com/files/yrgcnjaxew4.png)
+
+## how to use 
+
+first, rename the config_example.yml to config.yml. or start afresh, your choice.
+
+if you wish to upload to imgchest and use those links instead, use `--upload`
+
+If it is the first time you are uploading, you will have to install postgresql first if not already installed. 
+
+
+### install
+
+you can install the pixBoards package from PyPi
+
+`pip install pixBoards`
+
+or clone the repo.
+
+`git clone https://github.com/flynnsharwood/boards_v2.git`
+
+### First time upload
+If it is the first time you are uploading, you will have to install postgresql first if not already installed. 
+
+Also, if you have a LOT of files to upload for the first time, go to the uploader folder. [repo link](https://github.com/flynnsharwood/imgUploader)
+
+1. set up the directories list in config.yml
+1. run listFiles.py. it will create a file named "MediaFiles.py"
+2. now run calc_hex.py
+3. run fileListUpload.py
+
+fileListUpload basically uploads in batches of 20, unlike the original script where it uploads each image individually. This will upload and cache the links and hashes to postgress db
+
+### Usage
+simply use the binary file provided `boards.exe` 
+
+Or do `python3 cli.py` or `python3 __main__.py`
+
+flags you might use
+
+`--upload` ensure all files are being uploaded. If you have pictures with the same filenames in different folders, you might need to fix this.
+
+`--gitPush` this will push your created html files to a github repo. set up your repo to trigger a gh_pages deployment every push.
+
+`--config` change the config file being used
+
+
+here is a link to an example board - [https://flynnsharwood.github.io/exampleBoard/index.html](https://flynnsharwood.github.io/exampleBoard/index.html) 
+
+---
+## features
+
+added an button to load a random page in 0.2.18
+
+
+---
+

pixboards-0.2.25/pixBoards/__init__.py

@@ -0,0 +1,25 @@
+import os
+import subprocess
+
+# this gets the latest git commit hash. i will not be setting the version in the setup.py.
+# def get_git_version():
+#     try:
+#         commit_hash = (
+#             subprocess.check_output(["git", "rev-parse", "--short", "HEAD"])
+#             .decode()
+#             .strip()
+#         )
+#         return commit_hash
+#     except Exception:
+#         return "untracked"
+
+
+# __version__ = get_git_version()
+__version__ = "0.2.25" 
+
+templates_folder_path = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "templates"
+)
+
+with open(os.path.join(templates_folder_path, "configTemplate.yml"), "r") as f:
+    configTemplate = f.read()

pixboards-0.2.25/pixBoards/__main__.py

@@ -0,0 +1,4 @@
+from pixBoards.cli import main
+
+if __name__ == "__main__":
+    main()

pixboards-0.2.25/pixBoards/arguments.py

@@ -0,0 +1,66 @@
+import argparse
+
+# Parse arguments
+parser = argparse.ArgumentParser(description="Generate HTML for media directories.")
+parser.add_argument(
+    "--random",
+    type=int,
+    help="number of images to sample from all boards. "
+    "use a number higher than the number of total images, or a negative number,"
+    " to shuffle instead",
+)
+parser.add_argument(
+    "--recent",
+    "--desc",
+    type=int,
+    help="sorts filename by decending and truncates to input count.",
+)
+parser.add_argument(
+    "--ranDir",
+    type=str,
+    help="Directory to search images in for --random",
+)
+parser.add_argument("--dir", type=str, help="Directory to use for the images")
+# parser.add_argument("--csvs", nargs="+", help="List of CSV files to use")
+parser.add_argument(
+    "--useLists", action="store_true", help="Use list files from config"
+)
+parser.add_argument("--imageLists", nargs="+", help="List of imagelist files to use.")
+parser.add_argument("--col", type=int, help="Number of columns to default to")
+parser.add_argument("--margin", type=int, help="Margin in px")
+
+parser.add_argument(
+    "--sidecar", action="store_true", default=False, help="use links from sidecar files"
+)
+parser.add_argument(
+    "--includeLocal",
+    action="store_true",
+    default=False,
+    help="include local files if using lists",
+)
+parser.add_argument(
+    "--makeConfig",
+    action="store_true",
+    default=False,
+    help="include local files if using lists",
+)
+
+# parser.add_argument("--rancount", type=int, help="number of images to sample from all boards. use a number higher than the number of total images to shuffle instead")
+parser.add_argument(
+    "--upload", action="store_true", default=False, help="Upload images to Imgchest"
+)
+parser.add_argument("--config", type=str, default=False, help="config file to use")
+parser.add_argument(
+    "--saveBoards", action="store_true", help="Save generated boards to PostgreSQL"
+)
+parser.add_argument(
+    "--gitPush", action="store_true", help="Push outputDir to existing Git repo"
+)
+parser.add_argument("--useSaved", action="store_true", help="use only saved images")
+parser.add_argument(
+    "--reddit",
+    action="store_true",
+    help="this is helpful for --desc when using reddit images. (the id in the front of filename is converted to int using base 36)",
+)
+
+args = parser.parse_args()

pixboards-0.2.25/pixBoards/boardmakers.py

@@ -0,0 +1,321 @@
+import os
+import random
+from pathlib import Path
+
+import psycopg2
+
+from pixBoards.arguments import args
+from pixBoards.classes import board
+from pixBoards.imgchest import append_sidecar_links, process_images
+
+# append_sidecar_links not working properly rn. a future me problem.
+from pixBoards.log_utils import setup_logger
+
+from pixBoards.config_loader import config, outputDir
+
+
+# import yaml
+
+
+logger = setup_logger(__name__)
+
+
+# from pixBoards.config_loader import config
+
+
+def boardsForImglist(imgList_List, listDir, paginate):
+    # Now I might need to sanitise the ( image list )list
+    # so that there aren't instances with the same name.
+    # But as the imagelist files are in the same folder,
+    # they won't have the same name, so I leave this for the future me.
+    os.makedirs(listDir, exist_ok=True)
+
+    boards = []
+
+    for idx, imgListFile in enumerate(imgList_List):
+        boardName = os.path.splitext(os.path.basename(imgListFile))[0]
+        with open(imgListFile, "r", encoding="utf-8") as f:
+            images = [line.strip() for line in f if line.strip()]
+
+        outputFile = listDir
+        logger.info(f"output file = {outputFile}")
+
+        b = board(
+            name=boardName,
+            output_file_loc=outputFile,
+            image_paths=images,
+            paginate=paginate,
+            # images_per_page=config["page_size"] if paginate else 10000,
+            img_list_status=True,
+        )
+        b.paginate_board()
+        boards.append(b)
+
+    return boards
+
+
+def standardBoards(directories, outputDir, paginate, upload):
+    boards = []
+    # outputDir = Path(outputDir)
+    # outputDir.mkdir(parents=True, exist_ok=True)
+
+    media_extensions = (
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".bmp",
+        ".webp",
+        # ".heic",  # i will possibly add support to convert these to normal imgs
+        # before using them.
+        ".mp4",
+        ".avi",
+        ".webm",
+        ".mov",
+    )
+
+    for d in directories:
+        # normalize to a Path
+        src_dir = Path(d)
+
+        if not src_dir.exists():
+            logger.warning(f"Skipping non-existent directory: {src_dir}")
+            continue
+
+        for root, dirs, files in os.walk(src_dir):
+            image_paths = []
+
+            for fname in sorted(files):
+                if fname.lower().endswith(media_extensions):
+                    abs_path = Path(root) / fname
+                    image_paths.append(abs_path.resolve().as_uri())
+
+            logger.debug(f"Processing {root} with {len(image_paths)} images.")
+
+            rel = Path(root).relative_to(os.path.dirname(src_dir))
+
+            board_name = str(rel).replace(os.sep, "_~")
+            output_path = outputDir  # everything writes into this one folder
+            # collect local files
+            local_files = [
+                Path(root) / f
+                for f in sorted(files)
+                if f.lower().endswith(media_extensions)
+            ]
+            if not local_files:
+                logger.debug(f"No media in {root}, creating empty board.")
+                b = board(
+                    name=board_name,
+                    output_file_loc=str(outputDir),
+                    image_paths=[],
+                    paginate=paginate,
+                    upload=upload,
+                    dummy_status=True,
+                )
+            else:
+                # create a Board object and paginate it
+                b = board(
+                    name=board_name,
+                    output_file_loc=str(output_path),
+                    image_paths=image_paths,
+                    paginate=paginate,
+                    upload=upload,
+                    dummy_status=False,
+                )
+
+            b.paginate_board()
+            boards.append(b)
+
+            logger.debug(f"Board created: {board_name} ({len(image_paths)} images)")
+
+    return boards
+
+
+def uploadBoards(directories, outputDir, paginate, upload=True):
+    def connect_db():
+        return psycopg2.connect(
+            dbname=config["dbname"],
+            user=config["user"],
+            password=config["password"],
+            host=config["host"],
+        )
+
+    conn = connect_db()
+    boards = []
+    outputDir = Path(outputDir)
+    outputDir.mkdir(parents=True, exist_ok=True)
+
+    media_extensions = (
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".bmp",
+        ".webp",
+        ".mp4",
+        ".avi",
+        ".webm",
+    )
+
+    for d in directories:
+        src_dir = Path(d)
+        if not src_dir.exists():
+            logger.warning(f"Skipping non-existent directory: {src_dir}")
+            continue
+
+        for root, _, files in os.walk(src_dir):
+            rel = Path(root).relative_to(os.path.dirname(src_dir))
+            board_name = (
+                src_dir.name if rel == Path(".") else str(rel).replace(os.sep, "_~")
+            )
+
+            local_files = [
+                Path(root) / f
+                for f in sorted(files)
+                if f.lower().endswith(media_extensions)
+            ]
+
+            if not local_files:
+                logger.debug(f"No media in {root}, creating empty board.")
+                boards.append(
+                    board(
+                        name=board_name,
+                        output_file_loc=str(outputDir),
+                        image_paths=[],
+                        paginate=paginate,
+                        upload=upload,
+                        dummy_status=True,
+                    )
+                )
+                continue
+
+            logger.debug(f"Uploading {len(local_files)} images from {root}…")
+            try:
+                # local_files = append_sidecar_links(local_files, conn) # fix this function.
+                #  this function has problems in the images not being counted in the index maker or the randomiser.
+                http_links, hash_map = process_images(local_files, conn)
+                img_filenames = [f.name for f in local_files]
+            except Exception as e:
+                logger.error(f"Failed to upload images in {root}: {e}")
+                continue
+
+            b = board(
+                name=board_name,
+                output_file_loc=str(outputDir),
+                image_paths=http_links,
+                img_filenames=img_filenames,
+                paginate=paginate,
+                # images_per_page=(config["page_size"] if paginate else 10000),
+                upload=upload,
+                # no_of_imgs=len(http_links),
+                # outputDir=outputDir
+            )
+            b.link_hash_map = hash_map
+            b.paginate_board()
+            boards.append(b)
+            logger.debug(
+                f"Uploaded board created: {board_name} ({len(http_links)} images)"
+            )
+
+    conn.close()
+    return boards
+
+
+def randomBoard(boards, count, outputDir, paginate, upload):
+    images = []
+    for b in boards:
+        images.extend(b.image_paths)
+
+    try:
+        ran_images = random.sample(images, count)
+    except:
+        random.shuffle(images)
+        ran_images = images
+
+    images = list({os.path.basename(p): p for p in images}.values())
+
+    ranBoard = board(
+        name="randomised_set",
+        output_file_loc=outputDir,
+        image_paths=ran_images,
+        paginate=paginate,
+        upload=upload,
+        dummy_status=False,
+    )
+
+    ranBoard.paginate_board()
+
+    logger.info(f"there were {len(images)} imgs")
+
+    return ranBoard
+
+
+import re
+
+
+def extract_reddit_id_as_int(path: str) -> int:
+    filename = os.path.basename(path)
+    # Split on space or %20
+    reddit_id = re.split(r"(?:\s|%20)", filename, maxsplit=1)[0]
+    return reddit_id
+
+
+def descBoard(boards, count, outputDir, paginate, upload):
+    images = []
+    img_filenames = []
+
+    if upload:
+        for b in boards:
+            images.extend(b.image_paths)
+            img_filenames.extend(b.img_filenames)
+
+        # map filenames → paths
+        paired = list(zip(img_filenames, images))
+
+        # sort by filename (descending)
+        paired.sort(key=lambda x: x[0], reverse=True)
+
+        # deduplicate by filename
+        seen = {}
+        for fname, path in paired:
+            if fname not in seen:
+                seen[fname] = path
+        images = list(seen.values())
+
+    else:
+        for b in boards:
+            images.extend(b.image_paths)
+
+        if args.reddit:
+            images.sort(key=lambda x: extract_reddit_id_as_int(x), reverse=True)
+        else:
+            images.sort(key=lambda x: os.path.basename(x), reverse=True)
+
+        # deduplicate by basename
+        images = list({os.path.basename(p): p for p in images}.values())
+
+    # exclude top 10
+    top = 10
+    if count > 0:
+        images = images[top : count + top]
+    else:
+        images = images[top:]
+
+    desc_Board = board(
+        name="recent imgs",
+        output_file_loc=outputDir,
+        image_paths=images,
+        paginate=paginate,
+        upload=upload,
+        dummy_status=False,
+    )
+    desc_Board.paginate_board()
+
+    with open("desc_images.log", "w") as f:
+        for img in images:
+            f.write(f"{img}\n")
+    with open("desc_images_path.log", "w") as f:
+        for img in images:
+            f.write(f"{os.path.basename(img)}\n")
+
+    return desc_Board

pixboards-0.2.25/pixBoards/classes.py

@@ -0,0 +1,83 @@
+import os
+from datetime import date
+
+from pixBoards.config_loader import config
+from pixBoards.log_utils import setup_logger
+
+# set up logger
+today = date.today()
+logger = setup_logger(__name__)
+
+# masterDir = config["masterDir"]
+
+padding = config["padding"]
+imgs_per_page = config["page_size"]
+# print(f'imgs per page are {imgs_per_page}'  )
+
+
+class page:
+    def __init__(self, page_number, total_pages, images, file_location, bname):
+        self.page_number = page_number  # Current page number
+        self.images = images  # image list for the page
+        self.total_pages = total_pages
+        self.file_location = file_location
+        self.bname = bname
+
+
+from math import ceil
+
+
+class board:
+    def __init__(
+        self,
+        name,
+        output_file_loc,
+        image_paths,
+        # no_of_imgs,
+        img_filenames=[],
+        paginate=True,
+        upload=False,
+        dummy_status=False,
+        img_list_status=False,
+    ):
+        self.name = name
+        self.image_paths = image_paths
+        self.img_filenames = img_filenames
+        self.pages = []  # will be storing a list of instances of class, page.
+        self.imgs_per_page = imgs_per_page
+        self.output_file_loc = output_file_loc
+        self.upload_status = upload
+        self.paginate_status = paginate
+        self.link_hash_map = {} if self.upload_status else None
+        self.no_of_imgs = len(image_paths)
+        self.nested_boards = []
+        self.dummy_status = dummy_status
+        self.img_list_status = img_list_status
+        parts = self.name.split("_~")
+        self.clean_name = parts[-1]
+        self.parent = "_~".join(parts[:-1])
+
+    def paginate_board(self):
+        total_images = len(self.image_paths)
+        # logger.info(f'total images = {total_images}')
+        total_pages = ceil(total_images / self.imgs_per_page)
+        output_base = self.output_file_loc
+        for i in range(total_pages):
+
+            start = i * self.imgs_per_page
+            end = start + self.imgs_per_page
+            page_images = self.image_paths[start:end]
+            file_loc = (
+                os.path.join(output_base, self.name) + f"_{(i+1):0{padding}}.html"
+            )
+            Page = page(
+                page_number=i + 1,
+                total_pages=total_pages,
+                images=page_images,
+                file_location=file_loc,
+                bname=self,
+            )
+            self.pages.append(Page)
+            logger.debug(
+                f"Finished with - Board: {self.name}, page {i + 1} of {total_pages}"
+            )

pixboards-0.2.25/pixBoards/cli.py

@@ -0,0 +1,112 @@
+import time
+from datetime import date
+
+from pixBoards.arguments import args
+from pixBoards.boardmakers import (
+    boardsForImglist,
+    randomBoard,
+    descBoard,
+    standardBoards,
+    uploadBoards,
+)
+from pixBoards.log_utils import setup_logger
+
+logger = setup_logger(__name__)
+
+
+from pixBoards.config_loader import config, outputDir
+from pixBoards.db import create_boards_table, create_conn
+
+
+def main():
+
+    start_time = time.time()
+    today = date.today()
+    logger.info(f"Today is {today}, Starting ...")
+
+    conn = None
+    if args.upload or args.saveBoards:
+        conn = create_conn()
+
+    if args.saveBoards:
+        create_boards_table(conn)
+
+    paginate = config.get("paginate", True) is True
+    boards = []
+
+    # Handle imagelist mode
+    if args.useLists or args.imageLists:
+        usingLists = True
+        imgList_List = (
+            args.imageLists if args.imageLists else config.get("imageLists", [])
+        )
+        boards.extend(boardsForImglist(imgList_List, outputDir, paginate))
+
+        if args.includeLocal:
+            usingLists = False
+    else:
+        usingLists = False
+
+    # Handle upload
+    if args.upload:
+        logger.info("Upload case")
+        upload = True
+    else:
+        upload = False
+
+    if args.dir:
+        directories = [args.dir]
+        logger.debug("Using --dir → %s", directories)
+    elif config.get("directories"):
+        directories = config["directories"]
+        logger.debug(f"Using config.directories → %s", directories)
+    else:
+        directories = []
+
+    # board generation standar case
+    if directories and not usingLists:
+        if upload:
+            boards.extend(uploadBoards(directories, outputDir, paginate, upload=True))
+        else:
+            boards.extend(
+                standardBoards(directories, outputDir, paginate, upload=False)
+            )
+
+    # for random case
+    if args.random:
+        rancount = args.random
+        boards.append(randomBoard(boards, rancount, outputDir, paginate, upload))
+
+    if args.recent:
+        desc_count = args.recent
+        boards.append(descBoard(boards, desc_count, outputDir, paginate, upload))
+
+    from pixBoards.nest_boards import assign_nested_boards
+
+    root_boards = assign_nested_boards(boards)
+    logger.debug(root_boards)
+
+    # Group boards by output directory and create output
+    logger.info(f"Total boards to generate HTML for: {len(boards)}")
+    from pixBoards.filemaking import create_output_files
+
+    create_output_files(root_boards, boards, conn)
+
+    # Print nested board tree
+    def print_board_tree(boards, depth=0):
+        for b in boards:
+            print("  " * depth + f"- {b.clean_name}")
+            print_board_tree(b.nested_boards, depth + 1)
+
+    print("Boards structure - ")
+    print_board_tree(root_boards)
+
+    logger.debug(root_boards)
+    print(f"browse boards at - {outputDir}")
+
+    elapsed_time = time.time() - start_time
+    logger.info(f"Finished in {elapsed_time:.2f} seconds.")
+
+
+if __name__ == "__main__":
+    main()