toolvix 0.1.0__py3-none-any.whl

toolvix/__init__.py

@@ -0,0 +1,22 @@
+from .pdftools import (
+    pdfProtect,
+    pdfMerge,
+    pdfExtract,
+    pdfToword,
+    pdfToppt,
+    pptTopdf,
+    wordTopdf
+)
+
+from .imagetools import (
+    imageTopdf,
+    imageResize,
+    imageWatermark,
+    imageCompressor,
+    pdfToimage
+)
+
+from .filetools import (
+    fileEncrypt,
+    fileDecrypt
+)

toolvix/filetools/__init__.py

@@ -0,0 +1,2 @@
+from .encrypt import fileEncrypt
+from .decrypt import fileDecrypt

toolvix/filetools/decrypt.py

@@ -0,0 +1,36 @@
+from cryptography.fernet import Fernet, InvalidToken
+from pathlib import Path
+import base64
+import hashlib
+import getpass
+
+
+def fileDecrypt():
+    """Decrypt all .encrypted files in the current working folder."""
+    folder = Path.cwd()
+    password = getpass.getpass("Enter password: ")
+    key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+    cipher = Fernet(key)
+
+    files = sorted(folder.glob("*.encrypted"))
+    if not files:
+        print("No encrypted files found!")
+        return None
+
+    output_paths = []
+    for file_path in files:
+        try:
+            decrypted_data = cipher.decrypt(file_path.read_bytes())
+            output_file = file_path.with_name(file_path.name.removesuffix(".encrypted"))
+            output_file.write_bytes(decrypted_data)
+            file_path.unlink()
+            output_paths.append(output_file)
+        except InvalidToken:
+            print(f"Wrong password for: {file_path.name}")
+
+    if not output_paths:
+        print("No files were decrypted!")
+        return None
+
+    print(f"{len(output_paths)} files decrypted successfully!")
+    return output_paths

toolvix/filetools/encrypt.py

@@ -0,0 +1,32 @@
+from cryptography.fernet import Fernet
+from pathlib import Path
+import base64
+import hashlib
+import getpass
+
+
+def fileEncrypt():
+    """Encrypt all non-.encrypted files in the current working folder."""
+    folder = Path.cwd()
+    password = getpass.getpass("Enter password: ")
+    key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+    cipher = Fernet(key)
+
+    files = sorted(
+        file for file in folder.iterdir()
+        if file.is_file() and file.suffix != ".encrypted"
+    )
+
+    if not files:
+        print("No files found!")
+        return None
+
+    output_paths = []
+    for file_path in files:
+        encrypted_data = cipher.encrypt(file_path.read_bytes())
+        output_file = file_path.with_name(file_path.name + ".encrypted")
+        output_file.write_bytes(encrypted_data)
+        output_paths.append(output_file)
+
+    print(f"{len(output_paths)} files encrypted successfully!")
+    return output_paths

toolvix/imagetools/__init__.py

@@ -0,0 +1,5 @@
+from .imgtopdf import imageTopdf
+from .imgcompress import imageCompressor
+from .imgresize import imageResize
+from .imgwatermark import imageWatermark
+from .pdftoimg import pdfToimage

toolvix/imagetools/imgcompress.py

@@ -0,0 +1,70 @@
+from PIL import Image
+from pathlib import Path
+
+
+def imageCompressor(targetSizeMB=1):
+    folder = Path.cwd()  # Use the folder where the program is running
+
+    output_folder = folder / "compressed images"
+    output_folder.mkdir(exist_ok=True)
+
+    supported_formats = {
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".webp",
+        ".bmp"
+    }
+
+    target_size = targetSizeMB * 1024 * 1024  # Convert MB to bytes
+
+    # Find all images automatically
+    images = sorted(
+        [
+            image
+            for image in folder.iterdir()
+            if image.suffix.lower() in supported_formats
+        ]
+    )
+
+    if not images:
+        print("No images found!")
+        return None
+
+    output_paths = []
+
+    for image_path in images:
+
+        original_image = Image.open(image_path).convert("RGB")
+
+        quality = 95
+
+        # Always save compressed output as JPG
+        output_path = output_folder / (
+            image_path.stem + ".jpg"
+        )
+
+        # Reduce quality until target size is reached
+        while quality > 10:
+
+            original_image.save(
+                output_path,
+                "JPEG",
+                quality=quality,
+                optimize=True
+            )
+
+            if output_path.stat().st_size <= target_size:
+                break
+
+            quality -= 5
+
+        original_image.close()
+
+        output_paths.append(output_path)
+
+    print(
+        f"{len(output_paths)} images compressed successfully!"
+    )
+
+    return output_paths

toolvix/imagetools/imgresize.py

@@ -0,0 +1,32 @@
+from PIL import Image, ImageOps
+from pathlib import Path
+
+
+def imageResize(width=1920, height=1080):
+    """Resize all supported images without cropping, preserving aspect ratio."""
+    folder = Path.cwd()
+    output_folder = folder / "resized images"
+    output_folder.mkdir(exist_ok=True)
+    supported_formats = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+
+    if width <= 0 or height <= 0:
+        raise ValueError("width and height must be greater than 0")
+
+    images = sorted(image for image in folder.iterdir()
+                    if image.is_file() and image.suffix.lower() in supported_formats)
+    if not images:
+        print("No images found!")
+        return None
+
+    output_paths = []
+    for image_path in images:
+        with Image.open(image_path) as original_image:
+            resized_image = ImageOps.contain(original_image, (width, height))
+            if resized_image.mode in ("RGBA", "LA") or "transparency" in resized_image.info:
+                resized_image.save(output_folder / image_path.name)
+            else:
+                resized_image.save(output_folder / image_path.name)
+            output_paths.append(output_folder / image_path.name)
+
+    print(f"{len(output_paths)} images resized successfully!")
+    return output_paths

toolvix/imagetools/imgtopdf.py

@@ -0,0 +1,30 @@
+from PIL import Image
+from pathlib import Path
+
+
+def imageTopdf(output_file="photos.pdf"):
+    """Combine all supported images in the current folder into one PDF."""
+    folder = Path.cwd()
+    output_folder = folder / "converted pdfs"
+    output_folder.mkdir(exist_ok=True)
+    supported_formats = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+
+    images = sorted(image for image in folder.iterdir()
+                    if image.is_file() and image.suffix.lower() in supported_formats)
+    if not images:
+        print("No images found!")
+        return None
+
+    photos = []
+    try:
+        for image_path in images:
+            with Image.open(image_path) as image:
+                photos.append(image.convert("RGB"))
+        output_path = output_folder / output_file
+        photos[0].save(output_path, save_all=True, append_images=photos[1:])
+    finally:
+        for photo in photos:
+            photo.close()
+
+    print(f"PDF created successfully with {len(photos)} photos!")
+    return output_path

toolvix/imagetools/imgwatermark.py

@@ -0,0 +1,57 @@
+from PIL import Image, ImageDraw, ImageFont
+from pathlib import Path
+
+
+def imageWatermark(watermarkText="PREETAM", textSize=100, transparency=45, angle=25):
+    """Add centered watermark text to all supported images."""
+    if not 0 <= transparency <= 255:
+        raise ValueError("transparency must be between 0 and 255")
+    if textSize <= 0:
+        raise ValueError("textSize must be greater than 0")
+
+    folder = Path.cwd()
+    output_folder = folder / "watermarked images"
+    output_folder.mkdir(exist_ok=True)
+    supported_formats = {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+    images = sorted(image for image in folder.iterdir()
+                    if image.is_file() and image.suffix.lower() in supported_formats)
+    if not images:
+        print("No images found!")
+        return None
+
+    font_candidates = [
+        Path("C:/Windows/Fonts/arial.ttf"),
+        Path("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"),
+        Path("/usr/share/fonts/truetype/liberation2/LiberationSans-Regular.ttf"),
+    ]
+    font_path = next((p for p in font_candidates if p.exists()), None)
+    if font_path is None:
+        raise FileNotFoundError("No suitable TrueType font found for watermark text")
+    font = ImageFont.truetype(str(font_path), textSize)
+
+    output_paths = []
+    for image_path in images:
+        with Image.open(image_path) as source:
+            original_image = source.convert("RGBA")
+            width, height = original_image.size
+            temp = Image.new("RGBA", (1, 1))
+            bbox = ImageDraw.Draw(temp).textbbox((0, 0), watermarkText, font=font)
+            text_width, text_height = bbox[2] - bbox[0], bbox[3] - bbox[1]
+            text_layer = Image.new("RGBA", (text_width + 40, text_height + 40), (255, 255, 255, 0))
+            ImageDraw.Draw(text_layer).text((20, 20), watermarkText, font=font, fill=(0, 0, 0, transparency))
+            text_layer = text_layer.rotate(angle, expand=True, resample=Image.Resampling.BICUBIC)
+            x = (width - text_layer.width) // 2
+            y = (height - text_layer.height) // 2
+            original_image.alpha_composite(text_layer, (x, y))
+            output_path = output_folder / image_path.name
+            if image_path.suffix.lower() in {".jpg", ".jpeg"}:
+                original_image.convert("RGB").save(output_path, quality=95)
+            else:
+                original_image.save(output_path)
+            output_paths.append(output_path)
+            text_layer.close()
+            temp.close()
+            original_image.close()
+
+    print(f"{len(output_paths)} images watermarked successfully!")
+    return output_paths

toolvix/imagetools/pdftoimg.py

@@ -0,0 +1,27 @@
+import pymupdf
+from pathlib import Path
+
+
+def pdfToimage():
+    """Convert every PDF in the current folder into page PNG images."""
+    folder = Path.cwd()
+    output_folder = folder / "converted images"
+    output_folder.mkdir(exist_ok=True)
+    pdf_files = sorted(pdf for pdf in folder.iterdir()
+                       if pdf.is_file() and pdf.suffix.lower() == ".pdf")
+    if not pdf_files:
+        print("No PDF files found!")
+        return None
+
+    output_paths = []
+    for pdf_path in pdf_files:
+        pdf_output_folder = output_folder / pdf_path.stem
+        pdf_output_folder.mkdir(exist_ok=True)
+        with pymupdf.open(pdf_path) as pdf_document:
+            for page_number, page in enumerate(pdf_document, start=1):
+                output_path = pdf_output_folder / f"{pdf_path.stem}_page_{page_number}.png"
+                page.get_pixmap().save(output_path)
+                output_paths.append(output_path)
+
+    print(f"{len(output_paths)} images created successfully!")
+    return output_paths

toolvix/pdftools/__init__.py

@@ -0,0 +1,7 @@
+from .protect   import pdfProtect 
+from .merge     import pdfMerge
+from .extract   import pdfExtract
+from .pdftoppt  import pdfToppt
+from .pdftoword import pdfToword
+from .wordtopdf import wordTopdf
+from .ppttopdf  import pptTopdf

toolvix/pdftools/extract.py

@@ -0,0 +1,39 @@
+from pypdf import PdfReader, PdfWriter
+from pathlib import Path
+
+
+def pdfExtract(pages, output_file="extracted.pdf"):
+    folder = Path.cwd()  # Use the folder where the program is running
+
+    output_folder = folder / "extracted pdfs"
+    output_folder.mkdir(exist_ok=True)
+
+    # Find all PDFs automatically
+    pdf_files = sorted(folder.glob("*.pdf"))
+
+    if not pdf_files:
+        print("No PDF files found!")
+        return None
+
+    # Use the first PDF automatically
+    pdf_path = pdf_files[0]
+
+    reader = PdfReader(pdf_path)
+    writer = PdfWriter()
+
+    # Extract the selected pages
+    for page_number in pages:
+        writer.add_page(reader.pages[page_number - 1])
+
+    # Create the extracted PDF
+    output_path = output_folder / output_file
+
+    with open(output_path, "wb") as file:
+        writer.write(file)
+
+    print(
+        f"{len(pages)} pages extracted from "
+        f"{pdf_path.name} successfully!"
+    )
+
+    return output_path

toolvix/pdftools/merge.py

@@ -0,0 +1,32 @@
+from pypdf import PdfWriter
+from pathlib import Path
+
+
+def pdfMerge(output_file="Merged.pdf"):
+    folder = Path.cwd()  # Use the folder where the program is running
+
+    output_folder = folder / "merged pdf"
+    output_folder.mkdir(exist_ok=True)
+
+    # Find all PDFs in the current folder
+    pdf_files = sorted(folder.glob("*.pdf"))
+
+    if not pdf_files:
+        print("No PDF files found!")
+        return None
+
+    writer = PdfWriter()
+
+    # Add all PDFs to the merged file
+    for pdf_file in pdf_files:
+        writer.append(pdf_file)
+
+    # Create the output PDF
+    output_path = output_folder / output_file
+
+    with open(output_path, "wb") as file:
+        writer.write(file)
+
+    print(f"{len(pdf_files)} PDF files merged successfully!")
+
+    return output_path

toolvix/pdftools/pdftoppt.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+import pymupdf
+from pptx import Presentation
+from pptx.util import Inches
+
+
+def pdfToppt(output_file=None):
+    """Convert all PDFs in the current folder to PowerPoint files."""
+    folder = Path.cwd()
+    output_folder = folder / "converted ppt files"
+    output_folder.mkdir(exist_ok=True)
+    pdf_files = sorted(pdf for pdf in folder.iterdir() if pdf.is_file() and pdf.suffix.lower() == ".pdf")
+    if not pdf_files:
+        print("No PDF files found!")
+        return None
+
+    output_paths = []
+    for pdf_path in pdf_files:
+        ppt_name = output_file if output_file and len(pdf_files) == 1 else pdf_path.stem + ".pptx"
+        output_path = output_folder / ppt_name
+        presentation = Presentation()
+        presentation.slide_width = Inches(13.333)
+        presentation.slide_height = Inches(7.5)
+        with pymupdf.open(pdf_path) as pdf_document:
+            for page_number, page in enumerate(pdf_document, start=1):
+                pixmap = page.get_pixmap()
+                temp_path = output_folder / f".toolvix_temp_page_{page_number}.png"
+                pixmap.save(temp_path)
+                slide = presentation.slides.add_slide(presentation.slide_layouts[6])
+                slide.shapes.add_picture(str(temp_path), 0, 0, width=presentation.slide_width, height=presentation.slide_height)
+                temp_path.unlink(missing_ok=True)
+        presentation.save(output_path)
+        output_paths.append(output_path)
+
+    print(f"{len(output_paths)} PowerPoint files created successfully!")
+    return output_paths[0] if len(output_paths) == 1 else output_paths

toolvix/pdftools/pdftoword.py

@@ -0,0 +1,27 @@
+from pdf2docx import Converter
+from pathlib import Path
+
+
+def pdfToword(output_file=None):
+    """Convert all PDFs in the current folder to DOCX files."""
+    folder = Path.cwd()
+    output_folder = folder / "converted word files"
+    output_folder.mkdir(exist_ok=True)
+    pdf_files = sorted(pdf for pdf in folder.iterdir() if pdf.is_file() and pdf.suffix.lower() == ".pdf")
+    if not pdf_files:
+        print("No PDF files found!")
+        return None
+
+    output_paths = []
+    for pdf_path in pdf_files:
+        name = output_file if output_file and len(pdf_files) == 1 else pdf_path.stem + ".docx"
+        output_path = output_folder / name
+        converter = Converter(str(pdf_path))
+        try:
+            converter.convert(str(output_path))
+        finally:
+            converter.close()
+        output_paths.append(output_path)
+
+    print(f"{len(output_paths)} PDF files converted successfully!")
+    return output_paths[0] if len(output_paths) == 1 else output_paths

toolvix/pdftools/ppttopdf.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+
+def pptTopdf(output_file=None):
+    """Convert all PPTX files in the current folder to PDF using Microsoft PowerPoint."""
+    try:
+        import win32com.client
+    except ImportError as exc:
+        raise RuntimeError("pptTopdf requires Windows, Microsoft PowerPoint, and pywin32.") from exc
+
+    folder = Path.cwd()
+    output_folder = folder / "converted pdf files"
+    output_folder.mkdir(exist_ok=True)
+    ppt_files = sorted(ppt for ppt in folder.iterdir() if ppt.is_file() and ppt.suffix.lower() == ".pptx")
+    if not ppt_files:
+        print("No PowerPoint files found!")
+        return None
+
+    output_paths = []
+    powerpoint = win32com.client.Dispatch("PowerPoint.Application")
+    powerpoint.Visible = 0
+    try:
+        for ppt_path in ppt_files:
+            pdf_name = output_file if output_file and len(ppt_files) == 1 else ppt_path.stem + ".pdf"
+            output_path = output_folder / pdf_name
+            presentation = powerpoint.Presentations.Open(str(ppt_path), WithWindow=False)
+            try:
+                presentation.SaveAs(str(output_path), 32)
+            finally:
+                presentation.Close()
+            output_paths.append(output_path)
+    finally:
+        powerpoint.Quit()
+
+    print(f"{len(output_paths)} PowerPoint files converted successfully!")
+    return output_paths[0] if len(output_paths) == 1 else output_paths

toolvix/pdftools/protect.py

@@ -0,0 +1,38 @@
+from pypdf import PdfReader, PdfWriter
+from pathlib import Path
+
+
+def pdfProtect(output_file="protected.pdf", password="12345"):
+    folder = Path.cwd()  # Use the folder where the program is running
+
+    output_folder = folder / "protected pdfs"
+    output_folder.mkdir(exist_ok=True)
+
+    # Find all PDFs automatically
+    pdf_files = sorted(folder.glob("*.pdf"))
+
+    if not pdf_files:
+        print("No PDF files found!")
+        return None
+
+    # Use the first PDF automatically
+    pdf_path = pdf_files[0]
+
+    reader = PdfReader(pdf_path)
+    writer = PdfWriter()
+
+    # Copy all pages
+    writer.append(reader)
+
+    # Protect the PDF
+    writer.encrypt(password)
+
+    # Create protected PDF
+    output_path = output_folder / output_file
+
+    with open(output_path, "wb") as file:
+        writer.write(file)
+
+    print("PDF protected successfully!")
+
+    return output_path

toolvix/pdftools/wordtopdf.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+
+def wordTopdf(output_file=None):
+    """Convert all DOCX files in the current folder to PDF using Microsoft Word."""
+    try:
+        import win32com.client
+    except ImportError as exc:
+        raise RuntimeError("wordTopdf requires Windows, Microsoft Word, and pywin32.") from exc
+
+    folder = Path.cwd()
+    output_folder = folder / "converted pdf files"
+    output_folder.mkdir(exist_ok=True)
+    word_files = sorted(doc for doc in folder.iterdir() if doc.is_file() and doc.suffix.lower() == ".docx")
+    if not word_files:
+        print("No Word files found!")
+        return None
+
+    output_paths = []
+    word = win32com.client.Dispatch("Word.Application")
+    word.Visible = False
+    try:
+        for word_path in word_files:
+            pdf_name = output_file if output_file and len(word_files) == 1 else word_path.stem + ".pdf"
+            output_path = output_folder / pdf_name
+            document = word.Documents.Open(str(word_path))
+            try:
+                document.SaveAs(str(output_path), FileFormat=17)
+            finally:
+                document.Close()
+            output_paths.append(output_path)
+    finally:
+        word.Quit()
+
+    print(f"{len(output_paths)} Word files converted successfully!")
+    return output_paths[0] if len(output_paths) == 1 else output_paths

toolvix-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: toolvix
+Version: 0.1.0
+Summary: Simple dynamic file, PDF, and image automation tools for Python
+Author-email: "A.Preetam krishna" <preetam.200729@gmail.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: Pillow>=10.0
+Requires-Dist: pypdf>=4.0
+Requires-Dist: pdf2docx>=0.5.6
+Requires-Dist: PyMuPDF>=1.24
+Requires-Dist: python-pptx>=0.6.23
+Requires-Dist: cryptography>=42.0
+Provides-Extra: windows
+Requires-Dist: pywin32>=306; extra == "windows"
+
+# Toolvix
+
+Toolvix is a Python library for simple file, PDF, PowerPoint, Word, and image automation.
+Most functions automatically discover matching files in the **current working folder**, so users do not need to pass input filenames.
+
+## Installation
+
+```bash
+pip install toolvix
+```
+
+For PowerPoint/Word to PDF conversion on Windows, Microsoft PowerPoint and Microsoft Word must be installed, and install the Windows extra:
+
+```bash
+pip install "toolvix[windows]"
+```
+
+## Quick start
+
+```python
+from toolvix import *
+
+pdfMerge("final.pdf")
+pdfExtract([1, 2], "extract.pdf")
+pdfProtect("protected.pdf", "12345")
+
+imageTopdf("photos.pdf")
+imageResize(1920, 1080)
+imageWatermark("PREETAM")
+imageCompressor(1)
+
+fileEncrypt()
+fileDecrypt()
+```
+
+## API
+
+| # | Library | Package | Module | Function | Parameters | Dynamic Input | Output | Example |
+|---|---|---|---|---|---|---|---|---|
+| 1 | `toolvix` | `filetools` | `encrypt.py` | `fileEncrypt()` | None | All non-`.encrypted` files | Encrypted `.encrypted` files | `fileEncrypt()` |
+| 2 | `toolvix` | `filetools` | `decrypt.py` | `fileDecrypt()` | None | All `.encrypted` files | Decrypted original files | `fileDecrypt()` |
+| 3 | `toolvix` | `pdftools` | `merge.py` | `pdfMerge()` | `output_file` | All PDFs | One merged PDF | `pdfMerge("final.pdf")` |
+| 4 | `toolvix` | `pdftools` | `extract.py` | `pdfExtract()` | `pages, output_file` | First PDF | Extracted PDF | `pdfExtract([1, 2], "extract.pdf")` |
+| 5 | `toolvix` | `pdftools` | `protect.py` | `pdfProtect()` | `output_file, password` | First PDF | Protected PDF | `pdfProtect("protected.pdf", "12345")` |
+| 6 | `toolvix` | `pdftools` | `pdftoword.py` | `pdfToword()` | `output_file` (optional) | All PDFs | Word file(s) | `pdfToword()` |
+| 7 | `toolvix` | `pdftools` | `pdftoppt.py` | `pdfToppt()` | `output_file` (optional) | All PDFs | PowerPoint file(s) | `pdfToppt()` |
+| 8 | `toolvix` | `pdftools` | `ppttopdf.py` | `pptTopdf()` | `output_file` (optional) | All PPTX files | PDF file(s) | `pptTopdf()` |
+| 9 | `toolvix` | `pdftools` | `wordtopdf.py` | `wordTopdf()` | `output_file` (optional) | All DOCX files | PDF file(s) | `wordTopdf()` |
+| 10 | `toolvix` | `imagetools` | `imgtopdf.py` | `imageTopdf()` | `output_file` | All supported images | One PDF | `imageTopdf("photos.pdf")` |
+| 11 | `toolvix` | `imagetools` | `imgresize.py` | `imageResize()` | `width, height` | All supported images | Resized image(s) | `imageResize(1920, 1080)` |
+| 12 | `toolvix` | `imagetools` | `imgwatermark.py` | `imageWatermark()` | `watermarkText, textSize, transparency, angle` | All supported images | Watermarked image(s) | `imageWatermark("PREETAM")` |
+| 13 | `toolvix` | `imagetools` | `imgcompress.py` | `imageCompressor()` | `targetSizeMB` | All supported images | Compressed JPG(s) | `imageCompressor(1)` |
+| 14 | `toolvix` | `imagetools` | `pdftoimg.py` | `pdfToimage()` | None | All PDFs | Page image(s) | `pdfToimage()` |
+
+## Parameters
+
+### PDF tools
+- `pdfMerge(output_file="Merged.pdf")`: merges every PDF in the current folder in sorted filename order.
+- `pdfExtract(pages, output_file="extracted.pdf")`: extracts selected 1-based page numbers from the first PDF.
+- `pdfProtect(output_file="protected.pdf", password="12345")`: password-protects the first PDF.
+- `pdfToword(output_file=None)`: converts every PDF to DOCX. With one input PDF, `output_file` can set its output name.
+- `pdfToppt(output_file=None)`: converts every PDF to PPTX. With one input PDF, `output_file` can set its output name.
+- `pptTopdf(output_file=None)`: converts every PPTX to PDF. With one input PPTX, `output_file` can set its output name. Windows + Microsoft PowerPoint required.
+- `wordTopdf(output_file=None)`: converts every DOCX to PDF. With one input DOCX, `output_file` can set its output name. Windows + Microsoft Word required.
+
+### Image tools
+- `imageTopdf(output_file="photos.pdf")`: combines all supported images into one PDF.
+- `imageResize(width=1920, height=1080)`: resizes all supported images without cropping; aspect ratio is preserved.
+- `imageWatermark(watermarkText="PREETAM", textSize=100, transparency=45, angle=25)`: adds centered watermark text. `transparency=0` is invisible and `255` is fully opaque.
+- `imageCompressor(targetSizeMB=1)`: compresses all supported images to JPG, targeting approximately the requested size in MB.
+- `pdfToimage()`: converts every PDF page to a PNG image.
+
+### File tools
+- `fileEncrypt()`: asks once for a password and encrypts every non-`.encrypted` file in the current folder.
+- `fileDecrypt()`: asks once for a password and decrypts every `.encrypted` file. Successfully decrypted files replace their `.encrypted` versions with the original filenames.
+
+## Output folders
+
+Toolvix keeps generated files in separate folders such as `merged pdf`, `converted word files`, `resized images`, and `compressed images`.
+
+## Notes
+
+- Input files are discovered from `Path.cwd()`. Run your script from the folder containing the files you want Toolvix to process.
+- Do not store passwords or sensitive files in the working folder when using `fileEncrypt()`.

toolvix-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+toolvix/__init__.py,sha256=PlYrTKxbZa8hXQnWg8RuJ3nVHkXrpVf52_8-f4MsITU,308
+toolvix/filetools/__init__.py,sha256=SjpLJSPMmzhrhaNV2Lw3K54-FdvgTZdMUgt_8tnsWiI,66
+toolvix/filetools/decrypt.py,sha256=U6FFrt7mklZB-2418JHpHoqL9Otw8V8nxRgJzM-L_jw,1135
+toolvix/filetools/encrypt.py,sha256=CsbcI_S_2vBWqqrL0REn-eLFIOQPgR8IXUhtVBM03iw,947
+toolvix/imagetools/__init__.py,sha256=lD8qycygM8Q0eL1F4YcRmpD0RuaR7qWeJOLbJCj-e7s,183
+toolvix/imagetools/imgcompress.py,sha256=mf4lIhezIqxm-8weKNL4hfm-jLJcMaawPldVkksI12k,1581
+toolvix/imagetools/imgresize.py,sha256=fW3VUI3mK9RxnH7DiWQlUKPT5tLWKnRS7tXwV2hU0yc,1263
+toolvix/imagetools/imgtopdf.py,sha256=-Vm4jyAXow0z1r72QBSIRrjjY6bOFJdmYk18l65fOv0,1005
+toolvix/imagetools/imgwatermark.py,sha256=r-scEzkZkZ7ytwy8KxyTs5RckZYxSFfmg0WezrNjMlQ,2627
+toolvix/imagetools/pdftoimg.py,sha256=n0VMYqK17212RzOTGtxMAwDNsPgKUYPE_HSNI8W-JJo,1015
+toolvix/pdftools/__init__.py,sha256=D-6wsIzAX4Ul0iNCWwTcVD_mWkEwAu47sA72NCZXsP4,231
+toolvix/pdftools/extract.py,sha256=c0EOCqKRP8YTXKByui1oNVVxPYvLh_K6wCQ-BdILHdE,994
+toolvix/pdftools/merge.py,sha256=HZUSLBvZAByAlG_M4kwHiCVW3Q-bVsN1dNRSIGv6zJk,806
+toolvix/pdftools/pdftoppt.py,sha256=j1pjLaV1Fc_giAZoMK3kcZxCysM0RoK8bGb3fZTXPsQ,1617
+toolvix/pdftools/pdftoword.py,sha256=wvDuRMDRAJyXpoquuH5o4rDjMV7zL-629rbR1z7Tfhc,981
+toolvix/pdftools/ppttopdf.py,sha256=EJ1HHP6tEvC_G_Th3CCzF1ZnBF7Q5-X0tSk4uftt74E,1398
+toolvix/pdftools/protect.py,sha256=BjGO7wmBCqvRHfMJmqQnE_XqVEax9Aa5sQRbWTeMjQU,918
+toolvix/pdftools/wordtopdf.py,sha256=h63Ntaw7xH_LpXQph7Zq0YgdhE21_QBEhckVFlC7sgw,1334
+toolvix-0.1.0.dist-info/METADATA,sha256=W3hy0UwN0iaYiC5yLYozTINGLDEP2BSoN1i-rLz3fA8,5706
+toolvix-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+toolvix-0.1.0.dist-info/top_level.txt,sha256=vogmOy6IfKsGCgZIF8q-LJTG2z82oSyZAeadjYS-l_c,8
+toolvix-0.1.0.dist-info/RECORD,,

toolvix-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

toolvix-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+toolvix